Making Rich Web Application Architecture Usable
“Focus on the user and all else will follow” is a philosophy that can make or break a product.
Software designers have become notorious for concentrating on implementation patterns and neglecting the user. It is easy to get lost in grand concepts at an abstract level and get excited over stuff that makes your work as a developer easier; thus, the needs and desires of the "real" users may sometimes take a back seat. Identifying the usability constraints and designing within them keeps the focus on the user.
Users have certain basic likes and dislikes with various types of interaction. They are valid not only with human-computer interactions, but also in real life. Removing what users don’t like and concentrating what they do like is the first step towards improved user satisfaction. Listed below are 10 things that users hate:
Users Hate Learning
Learning requires a cognitive investment by the user. It doesn’t make sense to learn new interactions if there’s no return on the investment we must make to learn them. Using standard elements in the interface, and keeping those elements visually consistent among interactions, enables the user to learn once and then apply that knowledge anywhere. Real world metaphors can speed learning and help users understand the finest details, as they allow the designer to leverage what the user has already learnt in real life.
For example, the traveling metaphor that’s used on the World Wide Web makes it simple for everybody to surf, and a button’s bevel invites the user to ‘push’ it.
Each user has a different preexisting model in mind when they approach the interface. The interface should be flexible enough to accommodate all these user models. For example, a user might enter a phone number as 617-493-4984 or (617) 493 4984, so the interface should be prepared to accept either.
Characteristically, users will try to learn the positions of various elements in the interface and subsequently try to interact with them without looking at the element every time. Helping the user remember important elements and fixing those elements’ locations will improve the efficiency of learning. An interface should be clean and simple — this makes it easy for advanced users to remember things, and prevents new users getting lost in the interface. Categorizing elements into different groups keeps the interface uncluttered. Personas can also help developers prevent feature bloat and stay focused on the user.
Users can find it easier to learn new information little by little, so giving users a few new tasks at a time can be more effective than deluging them with information. The learning material shouldn’t hinder the user’s access to the real content, however; thus the elements in the interface should be both learnable and scanable. This will allow novice users to learn new features, while expert users will be able to perform tasks quickly.
Buttons, for example, should have text/tool tip and an icon. The text/tool tip makes a button learnable, while the icon makes it scanable. Maintaining a slow evolution of the interface also helps user learning and builds on previous successes to create a mature product. Testing new features on a minor portion of the real users provides the developer with an indication of realistic performance of the modifications, and allows slow evolution to occur.
Users Hate Repeating
No one likes entering data; we like to repeat data even less. How many times have you skipped entering personal information on the Web? How do you feel when you lose data you’ve spent time and effort entering (for example, a question or comment in a Web form)? Automatic data collection and the reuse of information will save your users the hassle of data entry.
Users want to obtain or write data once, and be able to use it anywhere. Any data that can be collected automatically, such as contextual information about the location, task, state, etc. should be acquired in this way. The prime advantage of rich Internet applications is that they keep the data rich even on the client side and enable reuse of the downloaded data with client side logic. Information must be able to flow, in accordance with the user’s interaction with the site, to other connected content. Using standard formats to store data will keep the user happy by making this kind of interoperability possible. By locking data into a particular application, users may use the application, but they’ll hate it if it doesn’t support a particular task they need.
The default values of the various components in the interface should reflect majority preferences, yet they should also be easily deleted so the user can set new values. For example, text fields should be filled with default values and pre-selected to allow easy deletion. Auto-completion is another way to reuse data even if the software doesn’t completely understand that data. Storing all data collected on the server gives the user a continuous experience across different devices. For this reason data should be backed up, instead of being overwritten, to prevent data losses.
Users Hate Waiting
Waiting for someone or something to appear is tedious. How many times have you grown bored waiting for a friend to show up? We hate waiting even more if we don’t know how long we have to wait. So it’s important to load data quickly and show progress — the user can plan and fit in other tasks. Giving users access to the previous task and showing progress will occupy the user’s attention and keep them informed while the data loads. Shifting between tasks while they wait requires user effort â€“ and is another reason why speed is important. Displaying partially loaded data will also help minimize the perceived wait.
If long wait times can’t be avoided, the user should be informed that they’ll receive an alert after the data loads.
Appropriate alerts should be sent on completion pending requests when the user goes back online. Different types of alerts are needed to prevent disturbing the user during an important task. For example, one type of alert pops up with a sound, irrespective of what the user is doing. Another alert type is aggregated in a list that the user will see when they’re free. One other pops up on a ticker within a side panel that the user will glance at when they’re available. Alerts should be configurable by the user.
Users Hate Searching
Not being able to find what you’re looking for can be frustrating. It’s not possible to remember where things are if their locations change frequently. Maintaining consistent navigation is important in helping users find the information they want. When we’re in a new place, we get around by asking someone for help, or by looking at signs. Similarly, search and navigation are very important in finding material in an online environment.
In the real world, we divide our time among tasks, and arrange information by topics. We also like to have as many of our needs met as possible in the one place — it’s simple and it saves time.
This is why supermarkets and shopping malls have proven so popular. In the case of Web applications, the user looks for tasks they can follow in order to achieve specific goals. A sequence of tasks makes a process; the process varies for different users. The designer might not be able to envisage during the design phase all the processes the user may want to follow within application. Some scenarios may change at a later stage; some scenarios may not even exist during the design phase. Therefore, it’s easier to ask where the user wants to go from a task, rather than list all the possible processes. If the interface is designed around a rigid process, users may feel locked in. One advantage of html is that the user can quickly and easily navigate through a site’s information in ways that the designer may not have expected. The application needs to allow the user to build personal processes that span a group of services and content as required.
Processes successfully direct users towards the goal, imposing minimal cognitive load, yet they restrict interesting work by creative users. Novice users like to follow tasks that fall into a default process. Tasks connected by rigid navigation systems are easier for them to use, though these same systems often restrict advanced users. In order not to stifle the user’s creativity, task-based interfaces should be loosely connected. Navigating from one task to another through the multiple facets into which those tasks fall suits advanced users well. Poorly designed interfaces are more likely to be organized around a specific function or internal structure, leaving the user to figure out which sequence of functions will accomplish their particular task. A task-oriented interface guides the user through sequences of actions by setting up tasks and linking them up via contextual navigation.
The user can also be directed towards an ideal process through efficient information architecture. The navigational data collected can also be used to direct users towards processes that others have followed. Microsoft’s task pane is a good example of the provision of contextual navigation between different tasks.
Separating the application into task-based interfaces and giving each task a URL enables them to be linked to from the Web. Linking from the Web to various tasks within the application will make the application easy for users to find.
Users Hate Reading
A picture says a thousand words. Would you wade through pages of tabular data if you could view that same information as a graph? Reading information as text requires our brain to visualize the data. Representing that information graphically can reduce this effort.
People are good at scanning, and we recognize and remember images more easily than text. Graphical elements more easily facilitate comparisons of length, shape, orientation, and texture. Animation can show changes across time. Color helps us make distinctions. Images help us achieve these aims much more effectively than does text.
Graphical elements are more accessible than text for most people, but some disabled users have problems assessing graphical elements. Computers can’t understand graphical data well either.
Text is a format that is universally interpretable. Thus the data coming from the server to the interface is more useful if it is textual. The interface should present this data in a way that’s accessible to all users.
Users Hate Security Breaches
While we’re happy to share some information with some people, we prefer to keep some information private. Unwittingly giving other programs access to private data can have disastrous consequences. For example, allowing any program to access a user’s Microsoft Outlook address book would open a can of worms.
Users don’t like to enter their information — they prefer it to be automatically collected. The developer must be able to control the sharing of this data in order to prevent security breaches. The user’s consent should be sought before their personal information or other collected data is shared. Listing the problems and advantages that may arise from the user allowing the site to share their information with others will help the user make the decision. If the user gives permission to share data, it should be made accessible to various other parties in standard formats.
Default security settings are very important, as few users bother to go through them. It is always better to begin with a strict security policy and loosen it as required than to try to move from a loose policy to one that’s strict. The security and privacy implications of all new features and data collected should be considered before implementation.
Users Hate a Monotonous Look
Monotonous interfaces are boring. Humans want to stand out in the groups we belong to, and want to spill our identities onto the things we use; we like our belongings to reflect our personality. Backgrounds, skins and sounds are a few ways to give users the ability to change the look of applications they use. A simple preference for setting the background and sounds will satisfy most users.
But, beware! While users like new looks, they don’t like to learn new interactions, which is why it’s better to keep the interface elements visually consistent with interactions â€“ this way, users won’t have to re-learn the interface if they apply a new skin to your application.
Users Hate Platform Restrictions
We hate those who stop us from doing what we want to. Laws have been made to prevent restrictions in the real world. “Make it accessible to anybody, anywhere!” should be the motto. Applications should not be restricted to a particular operating system, form factor, or user’s abilities.
Users like to learn to use the application once and then be able to use it anywhere: on the computer, on a handheld, or on a tablet. Users with varying abilities should also be able to access the application using specialized software.
The ability to deploy applications on various operating systems across different accessibility software is an important criterion when it comes to choosing the development platform.
Users Hate Rigid Functionality
One size does not fit all. A tool’s functionality is vastly reduced if it doesn’t fit the user perfectly. How would the world be if there was only one shoe size?
Options to add, remove and modify different functionality should be given to the user. It is unlikely that users will change all the preferences to make the application suit them. They expect the application will be custom made for them, or that it will know automatically what they want by following their actions.
Various presets can be made available to users according to different personas that you’ve identified as being likely to use the product. Preference setting can be made easier if the control panel is linked to from the context in which the user might want to make changes. A feature such as increased the font size can be very valuable to many users.
Users Hate Mistakes
We hate making mistakes, but often there’s no way to prevent them. Having the ability to undo our actions can allow us to recover from mistakes and learn from them. How great it would be if the undo feature were present in the real world!
Your application should keep track of all user actions and enable them to undo those actions. Auto-saving all actions prevents data loss if the application is closed by mistake. The data collected by the undo feature can also help the user to keep track of the navigation path they followed. Tracking user actions allows interesting metadata to emerge from the user’s interaction with the content; ways in which individuals might make use of that metadata to improve the way they work can also become apparent through this process.
Separating individual user actions can also help in the development of macros for repeating user actions. If a certain action is irreversible, a message saying “Are you really, really sure?” needs to be presented to the user before their request is effected. It’s better to back up the data and give the user the ability to undo their actions than to deluge the user with these messages.
Tracking all user actions has enormous benefit in the process of logging actions. The Web browser informs the site owner about the referrer page, but leaves a gap in tracking information when the user leaves the site. Rich Internet applications should be able to gather all user actions, which is of enormous value to the designer, and has the ability to determine the future path of the application.
“Release early and release often” is a principle that sees user feedback incorporated into the software quickly. Better feedback can be obtained by testing a new feature on a sample of real users. Errors that occur as users try to learn the interface and issues with the measurement itself can be minimized by direct testing.
A Usable Architecture
Even though we have decades of experience in software development, we have yet to solve the mysteries of software complexity. In order to develop usable rich Internet applications, it is necessary that the development process be as simple as possible, without neglecting any of the above usability constraints.
Patterns make it easier for the architect by providing them a system in which to store the lessons they’ve learnt. Most software patterns help the designer to cognitively grasp the problems encountered by others, and side-step them. A pattern that reduces complexity for the programmer without allowing them to lose track of the user will benefit the application designer.
To design a complex structure, one powerful technique is to discover viable ways of dissecting it into semi-independent components that correspond to its many functional parts. The design of each part can then be carried out with some degree of independence — as each will affect the others largely through its functionality — and independent of the details of the mechanisms that accomplish the function.
The complexity of the application is reduced when it’s split into less dependent pieces. This separation into manageable parts will also make the application capable of evolution, rather than revolution, as this approach allows easy and small changes to be made.
The question now is: how do we split a rich Internet application so that designing under the above usability constraints becomes simpler? Dividing the application into pages and navigation will help. Each page is composed of data, components, logic, and presentation. The pages are encapsulated in the navigation shell, which again has data, components, logic and presentation.
The page is an aggregation of data, components, logic and presentation. All interactions that are carried out together are grouped to form a task. The page encapsulates all these interactions. The users interact by visualizing and modifying various objects on a page through different views. Modifying the object in one view could immediately be reflected in the other views in the page because the rich Internet application is dealing with the data model of the object, rather than the data view of the object.
Reflecting the data model locally will enable offline interactions as well. For example, a tabular data object can be shown in different views. The table with all the columns, a slider with the maximum and minimum values of a column, and tick boxes containing the values of a column are a few views of the table data object with which the user might interact. Adjusting the slider view should update the table view in real-time. The modifications that are made to the data can be sent to the server when the user connects to the network.
Separating the navigation from the page doesn’t mean that that the pages should not contain any links to other pages. If the page fits in a default process, the navigation should be integrated into it to help novice users. Clean and simple pages are easily learnable. Simplicity can be achieved by reducing the number of elements in the interface and by categorizing them into groups. The Interaction architect is responsible for the task-based page design.
Navigation provides links from a given page to various other pages, depending on the context of the user’s original location. It is an aggregation of navigation data, navigation logic, navigation presentation and navigation components within pages. Navigation data organizes the relations between a page and other pages into different facets.
Standard formats like Xfml (eXchangeable Faceted Metadata Language) can be used to store the navigation data. Other data, such as the navigation path followed by users, can also be used in navigation.
Having a consistent navigation layout supports easier browsing of the site’s pages. Categorizing related links or reducing the number of links makes the navigation simple. Giving a URL to the pages and making them accessible from the Web will make the applications findable.
The Information architect is responsible for the navigation layout and contextual linking of various pages.
Data is separated in rich Internet applications as it comes from the server or is collected separately on the client side. A few of the different types of data include application data, preferences data, logging data, and navigation data.
Some data exists only on the client side, but reflecting all data on the server provides the user with a consistent experience across various devices. The Web services on the server side handle the complexities of sending out the application data according to the requests received. Restricting shared data access and managing it efficiently among applications will help the site owner maintain security. Also, using standard formats to store data will achieve interoperability between applications.
Logic is the code that describes the behavior of the application. It connects components, presentation, and the data. Object oriented principles can be used to reduce the complexity in the logic. The application programmer is responsible for the logic that goes into the application.
Components are the basic building blocks of the interface. A few types of components are interaction components, data loading components, navigation components and agent/alert components.
Interaction components provide visualizations and get interactions from the user for a particular data type. Separation of the component from logic, data presentation, and structure will assist rapid development and give the application designer the flexibility to implement accessible user interfaces. The components should take in text and provide accessible visualizations to all users.
Providing various ways to input the same information helps users interact with the application without changing their user model. Auto-completion-capable components also reduce the work load on the user.
Ensuring the learnability and scanability of components make them easy for both novice and advanced users. The components should be able to log user actions and take in actions to enable the undo feature.
Real world metaphors and affordances enable the user to interact with the software without learning new things. Various metaphors can be used to make the interaction with the components simpler.
The Web uses the travel metaphor, where users click on objects to go to a new page to perform an operation. Desktop applications use the workshop metaphor, where we have lots of tools to work on different selectable objects. In the morphic graphic system, the tasks appear on the objects itself after selecting it, which comes under the examine metaphor. A set of industry wide standard components following a consistent metaphor will make it possible for the user to learn once and use that knowledge anywhere.
Data loading components manage the data on the client and the server side. They provide the progress updates to the page, send partial data downloads to the interaction components and provide seamless online and offline data access. Navigation components encapsulate the page and navigation information in the application. Alert or agent components run in the background and give different types of alerts to the user.
Presentation deals with the visual display of the components. The location, sizes, colors and backgrounds of the components are defined by the presentation.
Consistent location for similar types of elements is encouraged by separating the presentation from the application. Most of the benefits that come with using CSS in Web pages apply here too. The visual designer is responsible for the presentation part of the application.
Advantages of the Pattern
In summary, the pattern provides the application designer and developer with a range of benefits that help them develop usable rich Internet applications. The pattern…
- decouples tasks according to expert domains, allowing semi-parallel application development
- allows the developers to work within usability constraints
- separates components from the software, enabling faster development
- creates an environment where the page is independent of navigation, which supports just-in-time processes
- makes presentation independent of pages, encouraging consistent page layout
- provides greater scalability of the application due to reduced complexity
- allows for easier maintenance through the splitting of the application into different parts
Even if the current tools do not support this pattern, it is advantageous to think of an application in this way because of the benefits it presents: it provides flexibility, gives independence to domain experts, and simplifies the problem with out losing track of usability constraints.
The availability of multiple options sometimes overwhelms new designers and increases complexity. The restrictions introduced through design patterns breed creativity under design constraints.
Patterns help reduce complexity and enable the easier understanding of a given problem. However, a design pattern is not a silver bullet or panacea to any problem, and should only be applied when the flexibility it affords is actually needed.
For more information, see:
HTML’s time is over. Let’s move on.
Macromedia central white paper.
Smart client application model and .NET framework.
Java Web start architecture.