Design Tidbits

back Tidbits Overview

Tools for Design and Visualization

Simplification

Interaction Design

Screen Design

Hierarchies

Visual Design

Design Process

Web, Web Applications, Web Design

Performance

Miscellany

 

 

Reducing Complexity

By Gerd Waloszek, SAP AG, SAP User Experience – October 27, 2000

The primary approach to creating simple and easy to use applications – be it for the Web or for traditional application platforms – is to follow the motto "less is more." In this article, a follow-up to the article on simplification "What Does "Simple" Mean?," I take a look at the options for reducing an application's complexity. Note that the different aspects of complexity typically go hand in hand. It usually does not suffice to focus on isolated areas when you try to simplify your application – you have to consider the whole range of options, as there are:

  • the application's purpose
  • functionality
  • data
  • screen elements
  • visual appearance

 

Purpose

"One Application – one purpose" – this simple rule is valid for any application, but it is especially true for simple applications like MiniApps (now called iViews) and Web applications (IACs). Applications which try to serve different purposes all at once are inherently complex and thus difficult to understand.

A valid alternative to multipurpose applications is to implement these as a set of simple stand-alone applications. Thus, you can offer those applications which correspond to the users' goals without disturbing them with unnecessary functionality.

 

Functionality

Many applications are loaded with functionality. These applications may be useful for professional users, but they may be insurmountable for beginners and untrained users. Even casual users may have problems using them. The following tips may help you to reduce your application's functionality.

Avoid Optional and "Nice-to-Have" Functionality

Simple applications like MiniApps or Web applications should only offer the necessary functionality. Reserve optional and "nice-to-have" functionality to applications for professional users. The typical approach to this is to follow the 80:20 rule: offer only that 20% of the functionality which is needed 80% of the time. But who knows what this magical 20% of functionality is? Well, if you have no idea, simply ask the users or observe them working.

Avoid Redundant Functionality

If you use a program like Adobe Photoshop(TM), you will after a while discover that you can achieve certain effects in numerous ways. This is good for a professional program, but experience shows that few beginners and casual users will ever discover these options. Therefore, if your application addresses beginners and casual users, avoid redundant functionality. Provide only one way of doing things, and make this one way easy to find. Redundant functions increase the overall functionality of your application, and thus increases its complexity.

 

Data

Data structures are often complex and the number of items to be handled by your application is huge. This, however, does not mean that you should bother your users with this complexity, as the following two tips show.

Separate the Presentation from the Internal Data Structure

Just because a complex data structure, for example a hierarchy, is stored as such in the computer that is by no means a good reason to present it that way to the user. Hierarchy levels are often used for technical or formal reasons, but are meaningless to users. As a guideline for presenting data to the users, ask how many category levels they need. Then present only those categories and let the "real" categorization be handled internally without the users being aware of it. Also, for a small number of items you may not need a hierarchy at all, as this only adds categories and levels to the items, thus making the data display unnecessarily complex.

Provide Easy to Use Means for Reducing the Number of Displayed Data

Filters separate data into views which are meaningful to the users and thus reduce the amount of displayed data. For example, a user may only be interested in his or her last ten task items or in the top ten selling products. If the user wants to see all the items, make it easy for him or her to change the view.

A shuffler in a MiniApp helps to reduce
         the amount of data displayed in a table

Figure 1: A shuffler in a MiniApp (now called iView) helps to reduce the amount of data displayed in a table

As the shuffler (see figure 1) is such a useful device, there will we a separate article on it. If you don't want to wait and want to learn more about the shuffler, please, consult the iView Guidelines in the Resources section of the SAP Design Guild (chapter Filtering Data - The Shuffler).

 

Screen Elements

Reducing complexity entails making the screen look as simple and "clean" as possible. Therefore, avoid the following more complex screen elements – or at least use them sparingly.

Menus

Pulldown menus were invented as a means to save screen space and to hide the functionality from the user's view when it is not needed. Over time, however, menus have turned into a vehicle for loading applications with hundreds of functions. These functions are distributed over several menu bar items, the organization and purpose of which many users do not understand: often users can be observed randomly scanning the menus for the functions they want to use. Cascading menus allow developers to squeeze in even more functionality, but also make it even easier to hide functionality from the users. Thus, menus are a perfect mechanism to make applications complex – and therefore a prominent candidate for reduction.

SAP's MiniApps and Web applications even don't have menus. This was first regarded as a restriction, but actually it is an advantage: it forces developers to reduce functionality – leaving no back doors open for additional functions.

Trees

Trees display complex information and are cumbersome to use. If possible, avoid using trees in simple applications, and consider alternatives like tables or lists. If your users are beginners or casual users, avoid trees with hierarchies more than two to three levels deep.

Note that if the number of tree elements is small – which should be the case in MiniApps and Web applications – hierarchies can be flattened to lists. The items may then follow some other ordering like an alphabetical or relevancy ordering, which helps users find things.

Tabstrips

Tabstrips may effectively reduce an application's complexity. They replace many screens with views, which reside within a stable work environment. When improperly used, however, tabstrips can themselves introduce complexity, especially if there are many views or if tabstrips are nested. Nested tabstrips are a perfect way of hiding information from the users, which is obviously not what you want.

Tables

Tables are fairly complex screen elements which often entice developers into squeezing in lots of information. Try to keep tables small with respect to the number of columns and rows.

For long tables consider effective filtering methods like the shuffler (see figure 1). These filters make it possible for users to look at just a few rows of data and avoid scrolling through and scanning large data sets.

Consider also alternative presentations like charts or graphs, which may reveal relevant information much faster and more directly than tables.

pie chart

Figure 2: The pie chart quickly reveals that parties 1 and 5 together have the majority in parliament and can form a government; finding this information in the table to the left takes much longer

Do not Offer Redundant Access Mechanisms to Functionality

In SAPGUI applications there are often quite a few access mechanisms to an application's functionality: menus, pushbuttons, function keys, keyboard shortcuts, accelerator keys, etc. For simple applications just use the basic mechanisms like pushbuttons and keyboard shortcuts.

 

Visual Complexity

The best functionality and information content is useless if users cannot find it. I already discussed this problem with regard to menus (functionality) and tabstrips (information). Generally, the cleaner a screen looks, the easier users can find information on it. The more cluttered, and thus complex the screen looks, the harder it is for users to do what they need to do, especially if time is at a premium. Here are a few hints on how you can reduce a screen's visual complexity.

Group Boxes

Use group boxes only if other ways of separating screen elements do not suffice. Group boxes add visual elements like borders which may make the interface hard to scan for information. Do not nest group boxes; separate groups within group boxes using lines or white space which are visually less complex (white space is to be preferred).

Frames, Borders and Lines

All these elements add to the complexity of screens without adding information. Use them only if screen content cannot be separated from each other by other means, e.g. by white space.

Decoration

Decoration, usually in the form of graphics may be "cool," but typically do not add any information. However, it adds to the number of screen elements and often make a screen more complex. Thus, when introducing decoration, check whether it really improves the presentation of the information at hand.

 

Conclusions

These are just a few tips on where you can start reducing complexity. To get the best application and screen design, try different design solutions or combinations of them and compare the results. Or, even better, test them with real users.

 

top top