You can create a great UI, but it will always piss some users off. The more flexible your UI, the more complex it will seem. So what's the best thing to do? Create a simple UI that's easy to use for most people, or create a flexible UI that's hard to learn but always does exactly what the user wants?
I don't think they are mutually exclusive but in the cases they are you have to look at what your customers want / need.
Any interface can be made simpler by moving complex functionality out of the way to some other place. I think that is the main trade off. To make it easier to use for the average user you have to make it more complicated for the power user. They have to do a few more clicks to get their stuff.
But of course quite often the software can be made easier for both power users and casual users without sacrificing usability for any of them. A key thing is to create orthogonal features than can be combined easily. Often software is complicated because there are a lot of overlapping features. Instead by making a few distinct features that can be easily combined the software can be made a lot more flexible and simpler.
Figure it out by making an object / action matrix. List the number of different objects in your app along one axis and the actions you can perform on them on another axis. The matrix should not be too sparse.
I don't know if there is an easy answer to this question. But there are some great quotes that reflect my opinion on the subject.
You can often find this quote inside books and articles concerning usability and design:
"Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away." - Antoine de Saint-Exupery
Taken out of context this may seem to advocate simplicity above all else. It's a great quote and it is indeed a great exercise to remove useless bits from your design to make it more intuitive. But I think the idea behind it is incomplete when it comes to user interfaces.
I think this sums it up best:
"It can scarcely be denied that the supreme goal of all theory is to make the irreducible basic elements as simple and as few as possible without having to surrender the adequate representation of a single datum of experience." - Albert Einstein
Or, to put Einstein's words in plain terms:
Everything should be made as simple as possible, but no simpler than is necessary.
I constantly try to think from this perspective. Do we really need this thing in our application? Most importantly, will anyone really miss it if it's gone? Conversely, what's missing from the application that we know everyone wants? Those decisions are all made based off of what the majority of users really need to use your software effectively, and nothing more.
Personally, I suppose I would make the UI just as clean, simple, and easy to use as possible for your given functionality. Then, if lots of people complain about this feature not being collapsible, or that toolbar not being movable, then you can address that when it comes.
Eric Burke on Simplicity:
To an extent, you can do both. Keep it as simple as possible for most users and use progressive disclosure to reveal the more advanced options for users that need them. Keep in mind, however, that more does not always equal better. Option overload occurs when there are so many choices that the user feels overwhelmed and frustrated.
I'll reproduce here a small rant about the evils of advanced UI flexibility in the last 4 or 5 paragraphs of this entry on my blog about an aspect of Outlook's UI.
Now, there are those who might see this as a triumph of Microsoft usability. After all, I had a problem, and thanks to the flexibility they built in, I was able to fix it. Yay Microsoft! right?
Well, not quite. See, the trouble with customisable interfaces is that they occasionally get customised.
See, now that I have made this alteration, if any of the rest of the 99.99% of highly habitualised Microsoft Outlook users who not only haven’t modified their toolbar, but don’t even know it can be done, attempt to use the one I have now changed, they will have a much harder time finding Reply to All.
Also, if I was to actually get really, really used to it, and perhaps even began to rely on it, I would also have a moment of confusion when I went to use an uncustomised version - which will inevitably happen, if only when something gets reinstalled sometime and the setting is lost. So although I have indeed been able to try a solution, it is not likely that I’ll make using it this modified way a truly instinctive habit. Doing that would just be inviting problems for myself further down the track.
A better approach from a usability purist’s standpoint would have been just to get it right in the first place :-)
Of course, 'getting it right' is easier said than done.
They're not necessarily mutually exclusive. For instance, GMail is a complicated UI that is easy to learn. Excel is a rich, deep UI that has many hidden complexities - but the learnability is high due to its immediate shallowness (all you need to do to use it is click in a cell and start typing).
I think the question touches more on issues with discoverability. If you create a simple UI but hide all the interactions behind menus, you can still mess it up, even if the menus aren't very deep. Similarly, you can create a really easy to use UI by focusing on the right things and using graphic design elements well (such as weight, typography and colour) to focus the user's attention on the right things.
There's a lot to draw on from videogames. One thing they do well is have players learn the "interface" in self-reinforcing loops that grant high satisfaction. A great example is in Super Mario, where jumping is a basic gameplay verb, but the user can easily discover a more advanced form of jumping by doing so several times in succession. Each time a successive jump connects, the player is given a small reward in the form of Mario whooping more loudly with each jump. There's definitely a shortage of short feedback loops like that in modern UI design.
IMHO, flexibility is too often an excuse for not implementing a UI well in the first place.
However, you can have both. Write a simple UI in a fairly easy to understand language, like Lua. Give parts of the interface a tiny button which a user can press to bring up the Lua code for that bit. Then they can freely edit the UI.
This is an interesting related article by Mike Rundle: http://flyosity.com/iphone/kill-the-settings-build-opinionated-software.php Even if it's not of help, it's still a good read.
Go for simplicity and forget flexibility, Microsoft has done research about this when they developed Office 2007, I'll give you two quotes from this post
What users say: ...talking to some of our expert users within large companies, who in several cases assured us that "everyone" customizes their UI...
What actually happens: In fewer than 2% of sessions, the program was running with customized command bars.
Forget UI customization, you'll get better result from focusing on making the "default UI" better.
Edit: Let me clarify, what I'm saying is that given you have finite development resources, if you spend those resources on optimizing the default UI the application will be better than if you spend the time building UI customization.
The application will be better for the 98% that never use customization and the application will be better for most of the 2% who do customize (to work around a UI problem you can solve for everyone).
As a result of having an application that is nicer to use you will get more sales (including from the 2% who would have used customization).
When was the last time you said "Application A is a pleasure to use and application B has a crappy UI, but I prefer B because I can rearrange the toolbars"?
The key to providing good simplicity is to have good modularity. http://www.ted.com/talks/george_whitesides_toward_a_science_of_simplicity.html is a good talk on the topic.
Every user request is simple in their mind and if you just did what they wanted, you'd have all the flexibility in the world.
Which is why you should start simple and only offer flexiblity in the simplest form they will accept once you've been able to get at the root of what they really need.
Many answers have used the Google interface as an example of simplicity, but what about the 'Advanced Search' functionality. Seems like they've managed to make it simple for most, but offer a more complicated solution for others. Obviously they have the resources to do both and have baked their code over many years.