General psychology: usability

That is how - psychology?

Some of our specialized companies that provide services in the usability market have for many years been staffed with certified psychologists (most often, graduates of engineering or general psychology departments). Indeed, for more than half a century, Russian-language psychology has been exploring the process of interaction between man and technology ( our first book on the topic ) and, in particular, the interfaces between the operator and the technical device. Of course, this terminology is purely ergonomic in nature, but this does not make it difficult to transfer knowledge to the IT environment (for example, Dmitry Satin , the founder of UsabilityLab, is a graduate of the ergonomic department of the psychology department of Moscow State University).

Psychological knowledge in Russia is poorly popularized, although in itself it can be very useful for developing software products. I will try to briefly outline some basic principles of design - as seen from the inside of classical psychological (mainly cognitive) works. I am sure that the IT industry does not need a buffer that is usability: you can learn how to apply psychological knowledge directly.

Usability root

Human processing capabilities are limited. The working memory , the “field of clear consciousness” cannot accommodate more than 5–9 elements, if it is only to recall, and more than 3-5 - if in parallel to do something else, for example, to construct a system model, to formulate a thought, to take away every second from hundreds three in mind and so on. Moreover, the capacity of a person as an information processing system is dynamic and directly depends on the data structure with which a person interacts. That is, the same task may turn out to be both easy and difficult for an abstract user, depending on how it is represented by the interface. The tasks that the user solves with the help of a software product are intrinsically complex, and some mental effort is required to solve them. To avoid internal complexity is impossible. The main task of the interface is to minimize the complexity of the external, the only source of which he himself is.





')

Purpose of usability design

The main goal of humane design is taking care of the user. The back-end developer will provide the consumer with the necessary means to solve his tasks, in response to this, the designer and usability engineer must make the tools available, and the interaction with the program is predictable. With these tools, a good product controls the emotional state of the user.

General psychological knowledge that will help us in this can be packaged in several basic principles.

The principle of minimizing effort

The main indicators of the convenience of the interface are the complexity of the tasks required by the user and the time spent on each of them. It is these indicators that determine the amount of effort that, according to the user, is spent on the implementation of the action. Indicators have different priorities depending on the activity being served by the interface.

Complexity Any action has its own, internal, complexity, from which it is impossible to get rid of, without making this action meaningless. For example, if you want to make a purchase, you cannot avoid financial transactions, as well as deciding on these transactions. These two actions will ensure the internal complexity of your activities. You will make a decision, most likely, without external intermediaries. However, at the stage of making financial calculations, you will use various means created within the community. Let it be paper money. In this case, the procedure of financial calculations will be decomposed into a sequence of movements, simple arithmetic and cognitive actions (allowing you to distinguish bills and coins from each other), supported by a feedback loop that corrects movements based on identification and arithmetic. All these actions impose requirements on you and are the external complexity of the task created by the imperfection of the "money-buyer" interface.

Thus, the external complexity of the problem is always the difference between the actual complexity of the task and the minimum possible complexity of the task. The minimum complexity of the mental task is achieved in the utopian case: any action is carried out in one psychological quantum, “one thought”, without the need for external actions and, especially, corrections. “Thought” as a unit of measurement is no good, but the pathos is simple: we minimize the number of actions, and especially - actions that are demanding to the characteristics of their execution. So, to get the cursor into the 10 * 10 button requires much more accurate sensorimotor coordination than the 100 * 100 button - this means it requires more effort (the notorious Fitts law takes time, but not effort, and ignores the context. However, it’s better than nothing). The assessment of the complexity of each behavioral action is based on psycho-physiological and - widely - ergonomic knowledge; Evaluation of mental actions is much more complicated and, so far, mainly based on experimental data on a variety of human limitations as an information processing system and population-based research results.

The main way to reduce the burden on the user is to organize information so that the focus of attention is 1-5 elements, which are:

1. Have the same or similar functions;
2. When interacting with them lead to similar results;
3. Report their sensory properties on all actions that can be done with them (the principle of economical mental model - below);
4. To interact with them do not require to remember anything but their own intentions.

The best tool, as you know, unnoticed. Working with a good interface, you notice it only if you are distracted from solving problems. When you work, there is only a goal and your actions to achieve it.



Time costs were more or less well formalized in GOMS-modeling (fully this method is applicable only to strictly regulated activities), which can be partially used in the development of any applications. In general, when developing an interface, it is not so important how much time the user spends on average to perform an action, the main thing is to correctly compose sequences of these actions that meet basic requests (scenarios are more important than actions). Time and mental costs are often in opposition. For example, when organizing a multilevel list, it is often necessary to choose between its width and depth: a deep list will reduce the mental cost of targeting each level, but will slow the user down the path to the item he needs; while a wide list will speed up element selection, but will significantly increase the workload due to an increase in the number of simultaneous alternatives.

The principle of economical mental model

Users simulate the application. No matter how simple your service is, each consumer will have a unique model, based on which he will design a sequence of actions to achieve his goals. In fact, the mental model is a metaphor of what is happening between the person and the application, allowing you to quickly navigate the laws by which the application is arranged, and the rules of interaction with him. This metaphor appears all for the same reason: the ability of a person to process information is limited, and all the rules in the "raw" form is simply impossible to remember: they are automatically combined into an economical (as far as possible) structure. Many developers dump the task of creating and maintaining a mental model of the application to users, arranging anarchy and provoking errors. The quality of the mental model can be easily assessed by the amount of instruction needed to complete the work or, if everything is not so bad, by the time it gets into the application (the time needed to master all the functions of the program that meet the needs of this user, and to realize the extent to which the demand for functions in the product his proposal). A mental model gives interface behavior predictability. If the average user after the initial familiarization with your product can correctly answer ten random interface questions out of ten, you have created a successful mental model. (Questions should concern the behavior of the interface, for example: “What happens if you press this button?” - or: “What should I do to ...?”)



Economical mental model:

1. Organized simply and hierarchically : uses as few objects and rules as possible, contains no exceptions, uses knowledge from everyday life (for example, analogies of interface elements to real things: an element that looks like a toggle switch cannot have both states active at the same time; zone, reacting to the cursor, there can be no more zone reacting to a click - otherwise contradictions arise);
2. Passed out : if your product is arranged (from the user's point of view!) In layers, visualize these layers. If it is an environment with events - provide a background and a good visibility of events on it;
3. It is unambiguous : if an element reports something about itself, then it reports only this and nothing else or contradictory (!);
4. Internally connected : additional connections between the structural units of the application reduce the final complexity of the mental model, displaying the same connection in several ways allows users with different activity styles to work with the product equally effectively.

Only when developing a product, one can understand its true structure, therefore developers are responsible for the mental model of the system transmitted in the interface. The model cannot take shape immediately, but it is the core of the interface, and not enough attention is given to it - it is inevitable that the program’s comprehensibility and usability can be reduced.

The mental model exists on several levels. Requirements for them are inherited from the bottom up: the necessary property of the button is a necessary property of the entire application and all intermediate levels. There are four main levels:

1. Element (button, link, scroll bar, text field ...), usability atom. At this level, the mental model should show the user three properties:
   
   
   • Whether the item is interactive
   • what interactions with the element are possible;
   • where each of these interactions will lead.
2. A block (navigation bar, list, text field with buttons and hints belonging to it ...). A block consists of elements, and an additional requirement of the mental model for it is integrity: the blocks are separated from each other spatially and with the help of feedback, the interaction between them is minimized. The number of elements in a block, as a rule, corresponds to the average amount of a person’s attention; therefore, it is the block that is the basic unit of user-application interaction, and understanding this gives us many opportunities to unload the user.
3. The page consists of blocks. There are two additional requirements for the page (regarding the first two levels). The first of them - an indication of the position in the structure of the site / application. A page is most often modeled as a space, a screen, a book spread, and so on: a system of blocks built into the space of the entire application, which has its unique address (as the user understands! Not the site’s path, but a place to which you can go through a certain sequence internal links and from which you can exit in the same way. The position of the page in the network of the application, the number of "inputs" and "outputs" determine its design. The second requirement for the page is functional unity. Each page is created for a specific purpose, and this goal is reflected in the attributes (style) of the page, the selection of blocks and their mutual arrangement.
4. The application consists of pages. The mental model of the application is its global function (what does this site do?) And structure (how is it organized? What is it made of? How to work with it?). An additional requirement for the mental model of the site: the transparency of its internal structure, the network of transitions between pages.

How to create a mental model?

How to transfer to the user all this information? To use text for this means, in fact, to write instructions, that is, capitulate to the task of building a mental model and dumping this task on the user = making the application incomprehensible. To convey the model with text, to teach the user, in principle, it is possible, however, requires a lot of training outside of usability: natural languages ​​have low expressive power when it comes to models. Therefore, it is much easier to transfer the mental model of the system to the user in images that are hidden by rules and analogies.



Hidden rules - the laws of the organization of the application of any level, expressed non-verbally. Often they are external to the application in nature, that is, they are inherited from a wider context. A rectangle with a height slightly larger than the line with the highlighted text appealing to the user (“What are you doing?”, “What's new?”, “Enter a description of the task ...”) is considered a text entry field. Its function does not follow from the form or other characteristics, but with the development of Internet technology, the value is fixed in the culture, and now to make, for example, a button with this appearance means to confuse the vast majority of users. This hidden rule is based on analogy.

Analogies - transfer of some properties of an object to another object, using the coinciding characteristics of images of the perception of these objects or ways of interacting with them. The text entry field on various walls in social networks is similar to the already written messages on the spatial characteristics (size and position), as well as the input and output fields of some technical devices (calculator and counting devices in the car, telegraph tape, handwritten line in the text). The most profitable analogies are with objects familiar to the user in real life. Typical examples are the cut tool (destroys content in one place, providing the ability to restore it in another), subject icons (door ajar - exit, gear - mechanical device, settings; speaker with waves near it - sound), page-by-document view in text editors, file systems of all popular operating systems (and the word “file” itself). Finding a GUI product that doesn’t use analogies is nearly impossible. It is precisely the analogies of D. Norman that laid the basis of the principle of natural conformity , emphasizing with this name the necessary intuitiveness of analogies, their clarity without reflection.

Principle of inerrancy

All users make mistakes. As in the case of complexity, the task of the ideal usability engineer is to save the user from errors caused by the program and allow him to correct the mistakes made by his own fault. In the first approximation, something can go wrong on two levels: motor and semantic . Typical errors of the motor level - inaccurate positioning of the cursor when clicking, miss on the key, incorrect identification of the letter. Errors of the semantic level are incorrect identification of a word, committing an unintentional action, forgetting intentions ... In most cases, the level of error does not matter much, but there are situations in which protection against a particular type of error fundamentally changes the person’s dialogue with the program.

Possible user errors are often impossible to model without taking into account his state, and this factor determines much in the interaction of the consumer with the product. A tired, thoughtful or agitated (toned) user is more likely to make errors of both levels that are impossible for the user in optimal working condition .

Protection against motor errors - restrictions on the minimum font size and buttons, on the minimum distance between the borders of adjacent buttons.

Protection against semantic errors is the maximum distinguishability of functional elements, their reasonable grouping (the economization of the mental model) and, most importantly, obvious protection against destructive actions, especially if such actions are irreversible. Possible ways to protect against fatal errors:

• inaccessibility of destructive actions (dialogue structure),
• confirmation request (detailed, indicating the object of impact!)
• the ability to cancel the committed destructive action (protects not only from errors, but also from impulsive behavior).

How to reduce the load?

The concept of load, or cognitive load , is difficult to formalize, but in the laboratory for many years, studies have been conducted that simulate human interaction with various systems. These studies show several basic factors of mental load, on the basis of which you can get simple rules to reduce the load, that is, reduce the external complexity of the action:

1. Reminders and external memory: the less you need to remember the user, the better. He can even forget his own intention if several overloaded screens or at least one unpredictable event stand in the way of its implementation;
2. Continuity of activity and protection against interruptions : let the user complete the job before distracting him. After each distraction, it will take him time to remember what he was doing and to work on the interrupted activity - and the responsibility for this wasted time lies with the developer. But while the software knows little about the user. Full-fledged sensors have not yet become an indispensable attribute of the workplace, but they can make life much easier for us.

Of course, it’s impossible to start doing good interfaces with any text at once, like anything else. But the various rules of usability often give vague instructions to actions, without explaining the reasons (therefore they are doomed to erroneous applications), and with psychological knowledge in general they behave lively. I would like this to change.