General Psychology: usability

That is, how is psychology?


Some of our specialized companies providing usability services have been staffed by certified psychologists for many years (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 human-technology interaction ( 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 complicate the transfer of knowledge to the IT environment (for example, Dmitry Satin , founder of UsabilityLab, is a graduate of the most 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 design principles - as they can be seen from the inside of classical psychological (mainly cognitive) works. I am sure that the buffer, which is usability, is not needed in the IT industry: psychological knowledge can be learned to apply directly.


Usability root


Human information processing capabilities are limited. Working memory , the “area of ​​clear consciousness” cannot accommodate more than 5–9 elements if one is only engaged in recalling, and more than 3–5 if one is engaged in something else at the same time, for example, constructing a system model, formulating a thought, and subtracting hundreds three in mind and so on. Moreover, the throughput of a person as a system of information processing is dynamic and directly depends on the data structurewith which a person interacts. That is, the same task can turn out to be both easy and complex for an abstract user, depending on how it is presented by the interface. The tasks that a user solves using a software product have internal complexity, and some mental effort is required to solve them . It is impossible to avoid inner complexity. The main task of the interface is to minimize external complexity, the only source of which he himself is.



Usability design goal


The main goal of humane design is to take care of the user. The back-end developer will provide the consumer with the necessary tools to solve his problems, in response to this, the designer and usability engineer must make the tools available, and the interaction with the program is predictable. Using these tools, a good product controls the user's emotional state.
General psychological knowledge that will help us with this can be packaged into several basic principles.

Principle of minimization of efforts


The main indicators of the convenience of the interface are the complexity of the tasks the user needs and the time spent on each of them. It is these indicators that determine the amount of effort that, as perceived by the user, is spent on the execution of an action. Indicators have different priorities depending on the activities served by the interface.
Complexity. Any action has its own internal complexity, which cannot be eliminated without making this action meaningless. For example, if you want to make a purchase, you cannot avoid financial transactions, as well as making decisions about these operations. These two actions will ensure the internal complexity of your business. You will make the decision, most likely, without external intermediaries. However, at the stage of making financial calculations, you will use various funds 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 banknotes and coins from each other), supported by a feedback loop, which corrects movements based on recognition and arithmetic. All these actions make demands 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 task 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 measure is no good, but the pathos is simple: we minimize the number of actions, and especially - actions that require performance characteristics. So, getting to the 10 * 10 button with the cursor requires much more precise sensorimotor coordination than the 100 * 100 button - it means more effort (Fitts' notorious law takes time, but not effort, and ignores the context. However, better than nothing). The complexity assessment of each behavioral action is based on psychophysiological and - widely - ergonomic knowledge; assessment of mental actions is much more complicated and, so far, is mainly based on experimental data on various human limitations as a system for processing information and the results of population studies.
The main way to reduce the load on the user is to organize the information so that 1-5 elements are located in the focus of attention , which are:
  1. Have the same or similar functions;
  2. When interacting with them lead to similar results;
  3. They inform with their sensory properties about all the actions that can be performed with them (the principle of an 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, is imperceptible. Working with a good interface, you notice it only if you are distracted from the tasks being solved. When you work, there is only a goal and your actions to achieve it.

Time costs were more or less successfully formalized in GOMS modeling, (this method is fully applicable only to strictly regulated activities), which can partially be 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 needs (scenarios are more important than actions). Time and mental costs are often in opposition. For example, when organizing a multi-level list, you often have to choose between its width and depth: a deep list will reduce the mental costs of orientation at each level, but it will slow the user on the way to the element he needs; while a wide list will speed up the selection of an item, but significantly increase the load 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 may be, each consumer will have a unique model, based on which he will design sequences 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 structured and the rules for interacting with it. This metaphor appears all for the same reason: a person’s ability to process information is limited, and all the rules in a “raw” form are simply impossible to remember: they are automatically combined into an economical (as much as possible) structure. Many developers reset 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 easily be estimated by the volume of instructions necessary for full-fledged work or, if everything is not so bad, by the time it takes to work in the application (the time required to master all the functions of the program that meet the requirements of this user and to understand the degree to which demand for functions in the product is consistent his proposal). The mental model makes the behavior of the interface predictable. If the average user after the first acquaintance with your product can correctly answer ten random out of ten interface questions, you have created a successful mental model. (The questions should concern the behavior of the interface, for example: “What happens if you click this button?” - or: “What needs to be done to ...?”) by the time it takes to work in the application (the time required to master all the functions of the program that meet the requirements of a given user, and to realize the degree to which the demand for functions in the product corresponds to its offer). The mental model makes the behavior of the interface predictable. If the average user after the first acquaintance with your product can correctly answer ten random out of ten interface questions, you have created a successful mental model. (The questions should concern the behavior of the interface, for example: “What happens if you click this button?” - or: “What needs to be done to ...?”) by the time it takes to work in the application (the time required to master all the functions of the program that meet the requirements of a given user, and to realize the degree to which the demand for functions in the product corresponds to its offer). The mental model makes the behavior of the interface predictable. If the average user after the first acquaintance with your product can correctly answer ten random out of ten interface questions, you have created a successful mental model. (The questions should concern the behavior of the interface, for example: “What happens if you click this button?” - or: “What needs to be done to ...?”) If the average user after the first acquaintance with your product can correctly answer ten random out of ten interface questions, you have created a successful mental model. (The questions should concern the behavior of the interface, for example: “What happens if you click this button?” - or: “What needs to be done to ...?”) If the average user after the first acquaintance with your product can correctly answer ten random out of ten interface questions, you have created a successful mental model. (The questions should concern the behavior of the interface, for example: “What happens if you click this button?” - or: “What needs to be done to ...?”)

Economic mental model:
  1. It is organized simply and hierarchically : it 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, responding to a cursor hover, there can be no more zone that responds to a click - otherwise there are contradictions);
  2. Moved out : if your product is arranged (from the point of view of the user!) In layers, visualize these layers. If it is an environment with events - provide a background and good distinguishability of events on it;
  3. It is unequivocal : if an element communicates something about itself, then it communicates only this and nothing else or contradictory (!);
  4. Internally connected : additional connections between structural units of the application reduce the final complexity of the mental model, displaying the same connection in several ways allows users with different styles of activity to work equally effectively with the product.


Only by developing a product, you can understand its true structure, so developers are responsible for the mental model of the system transmitted in the interface. The model cannot be formed right away, but it is the core of the interface, and paying enough attention to it will inevitably reduce program comprehensibility and usability.
The mental model exists at 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:
    • Is the item interactive?
    • what interactions with the element are possible;
    • what each of these interactions will lead to.
  2. Block (navigation bar, list, text box with buttons and hints belonging to it ...). A block consists of elements, and an additional requirement of the mental model for it is integrity: blocks are spatially delimited from each other and using feedback, the interaction between them is minimized. The number of elements in a block, as a rule, corresponds to the average amount of attention of a person, therefore the block is the main unit of interaction “user-application”, and understanding this provides us with many opportunities to unload the user.
  3. Pageconsists of blocks. There are two additional requirements for the page (relative to the first two levels). The first of them is an indication of the position in the structure of the site / application. A page is most often modeled as a space, a screen, a spread of a book, and so on: a block system built into the space of the entire application, which has its own unique address (in the user's understanding! Not a path on the site, but a certain place where you can go through a certain sequence internal links and from which you can exit in the same way. Node in the application network). The position of the page in the application network, the number of “inputs” and “outputs” determine its design. The second page requirement 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 relative position.
  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 site’s mental model is the transparency of its internal structure, the network of transitions between pages.

How to create a mental model?


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

Hidden rules- laws of organization of an application of any level expressed non-verbally. Often they are external in relation to the application, that is, they are inherited from a wider context. A rectangle with a height slightly larger than a line with highlighted text that appeals to the user (“What are you doing?”, “What's new?”, “Enter a description of the task ...”) is considered a text input field. Its function does not follow in any way from the form or other characteristics, however, with the development of Internet technologies, the importance has become fixed in the culture, and now to make, for example, a button with such an appearance means confusing the vast majority of users. This hidden rule is based on analogy.
Analogies- transfer of some properties of the object to another object, using the matching characteristics of the perception patterns of these objects or ways of interacting with them. The text input field on various walls in social networks is similar to the already written messages on spatial characteristics (size and position), as well as the input and output fields of some technical devices (calculator and calculator line in a car, telegraph tape, handwritten line in the text). The most advantageous analogies are with objects familiar to the user in real life. Typical examples are the “cut” tool (destroys the content in one place, providing the opportunity to restore it in another), subject icons (ajar door - exit, gear - mechanical device, settings; speaker with waves around it - sound), page view of the document in text editors, file systems of all popular operating systems (and the word "file" itself). Finding a product with a graphical interface that does not use analogy is almost impossible. It is an analogyD.Norman laid the basis of the principle of natural correspondence , emphasizing with this name the necessary intuitiveness of analogies, their understandability without reflection.

The principle of faultlessness


All users make mistakes. As in the case of complexity, the task of an ideal usability engineer is to save the user from errors through the fault of the program and allow him to correct errors made through his own fault. In a first approximation, something may go wrong on two levels: motor and semantic . Typical errors at the motor level are inaccurate positioning of the cursor when clicking, miss on the key, incorrect recognition of the letter. Errors of a semantic level are incorrect recognition of a word, committing an unintentional action, forgetting an intention ... In most cases, the level of error does not matter much, however, there are situations in which protection from a particular type of error fundamentally changes a person’s dialogue with the program.
Possible user errors are often impossible to model without taking into account their condition, and this factor determines a lot in the interaction of the consumer with the product. A tired, thoughtful or excited (toned) user is more likely to make errors of both levels, impossible for the user in optimal working condition .
Protection against motor errors - restrictions on the minimum font size and buttons, the minimum distance between the borders of adjacent buttons.
Protection against semantic errors is the maximum distinguishability of functional elements, their reasonable grouping (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 influence!)
  • the ability to cancel the perfect 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, however, 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 user needs to remember, the better. He can even forget his own intention if several overloaded screens or at least one unpredictable event get in the way of its realization;
  2. Business Continuity and Interruption Protection : Give the user the opportunity to finish what they’ve started before distracting them. After each distraction, he will need time to remember what he was doing and to get used to interrupted activities - and the developer is responsible for this wasted time. But while software knows little about the user. Full-fledged sensors have not yet become an indispensable attribute of the workplace, but they can greatly facilitate our lives.


Of course, with no text at the ready, you cannot immediately start making good interfaces, like anything else. But the various rules of usability most often give vague instructions for action, without explaining the reasons (therefore, they are doomed to erroneous applications), and with psychological knowledge they generally behave like animals. I would like that to change.

Also popular now: