Designing Flexible Interfaces

No matter how well you design your application, someone will complain that some feature doesn't work as expected. During my years of programming, I've personally seen arguments between users about order of fields on a form. One discussion about a screen degenerated into an intense argument about the order of name elements on the form (one user wanted last name first ”the other wanted the first name to appear first). Users will grumble about every aspect of your application given a chance and you'll never satisfy all the users. Some developers solve the problem by giving up and creating the application they want. However, this solution probably works least often because the user's immediate reaction is that the developer isn't listening and lacks any form of human interaction skills.

Flexible user interfaces resolve the user problem by letting each user design the interface that meets their specific needs. Just how flexible you can make the interface depends on a number of factors including the application environment and the programming language you use. Making Web applications flexible is somewhat harder than for most desktop applications because many browsers lack the support required to move visual elements around and perform other manipulations the user would like. Depending on your programming skill, schedule, programming language, and patience, you can make some desktop applications so flexible that the user has control over every display element and the application will remember its configuration between sessions.

Let's start with something a little more reasonable than complete application configuration. Even the most mundane Web page allows configuration. For example, you can use Cascading Style Sheets (CSS) to format the Web page. Some browsers let the user substitute their CSS file for the default that you provide on your Web site ”making it possible for the user to have complete control over the presentation of information even if you don't provide any other form of programming with the Web page. Some sites extend this principle by providing multiple CSS files. A simple cookie entry controls which CSS file the Web site uses when presenting information to the user. Desktop applications are even easier to control in this area. All you need is an Options dialog box containing the display element settings so the user can change them to meet specific needs. Most desktop applications already provide this feature. Make sure you save the user options in a file or other central location (such as the Windows Registry) if you offer this feature.

The next level of application configuration is component selection. For example, not every Google Web Services user will want to sort the output results. It might seem that simply ignoring the sort field would work, but unnecessary fields are annoying to some users. Again, Web pages can use a cookie to store a list of fields or controls the user doesn't want to see. You'll likely have to provide a configuration page to support this form of application setup ”adding a simple link to the page to allow configuration usually works fine. Desktop applications can use an Options dialog box. Most desktop applications don't offer this feature ”likely because the developer didn't think to offer the feature or assumed that everyone would want access to every field.

Note  

Don't make every field on a form optional. A user will have to make some entries to perform even basic tasks . For example, a user can't perform a search without entering a search phrase, so the search phrase field isn't optional. However, hiding optional fields can make the application faster and easier to use. You might even find that you want to include some developer-only fields in the list that you control with special entries in the configuration file.

Web applications don't commonly use toolbars or special menus in the same way that desktop applications use them. However, both environments can benefit from some level of customization for both items. Quite a few desktop applications offer this feature. Generally, the user selects a special menu command that allows them to move menu or toolbar elements around, add new menu or toolbar options, or delete options the user feels aren't important. Trying to implement this feature on a Web site would be very hard, but doable if you use some technologies, such as ASP.NET. Make sure you offer a feature that returns everything to its default state in case the user makes a few too many changes.

The ultimate level of interface flexibility lets the user move controls around on screen. This feature lets one user place names in last name order and another user place them in first name order. Complete interface control is difficult to implement on a desktop application and likely impossible for a Web application. Applications that allow complete interface configuration are extremely rare. However, a Google Web Services application doesn't suffer from the level of complexity that some applications do, so this might be a viable solution in some cases. At least you can provide the user with enough flexibility to define precisely how the display appears so that your application works as efficiently for that user as possible.

Note  

If you plan to provide complete interface flexibility for your application, you should go all the way by allowing the user to change even mundane features such a font size and typeface. To an extent, you could even let the user change the button captions and control the color of the tiniest text element. It's even possible to let the user add graphics and perform other odd configuration changes given the right programming language, a platform that supports the changes, and enough time.