9 Principles of GUI design (third article)

Basic Principle 7: Delivering information, not just data
Principle 8: Design should meet response needs
Basic principle 9: Find an error through a user trial and fix it

7) Principle 7: Passing information, not just data
The computer promises a source of information. But they mostly pass on a lot of data ... Most of them are useless data. The data is not information. People need to extract information from the data.
Software applications often treat data as information. They throw data at you and let you find out for yourself what they mean. The software should focus the user's attention on important data and help them extract information from it.
7.1 Careful design display, get professional help
Kimu 2 mentions: "First consider the function." Then the expression ", but in any software development work, we sometimes have to consider how to represent the control and state of the software, but also consider the user's data. In this case, the designer should consider the screen design very carefully and carefully. Our goal is to:

• Visual order and user focus: A successful user interface design is not just a simple representation. It shifts the user's attention to the important content.
• Easy to navigate: computer users seldom read the screen carefully; they often browse quickly to find information that matches their goals. Therefore, the screen is designed to be easy to navigate. Do not use large paragraphs of text. To split the information into headings, points, lists, and tables. Use graphics to display information where possible. Link labels are short.
• Match media: One feature of poor user interface design is that the design does not match the limitations of the presentation medium. Well-designed user interfaces are well matched to the media they use.

• Attention to detail: success lies in detail. This is especially true in the design of information representations. Hiring user interfaces and graphic designers may seem to be expensive, but they can notice details that other developers rarely notice, so it's easy to repay the cost of hiring them. When a programmer must work without the support of a design expert, at a minimum, the design of the user interface should be arranged for the attention to detail. Otherwise, many GUI defects or errors may be committed in the product. such as inconsistent display, inconsistent design, hard-to-identify symbols, and an overall unprofessional look, this can hinder product success.

  7.2 screen belongs to the user
  The effective GUI principle is "screen belongs to User". The graphical user interface is built on the basis of the user's direct manipulation of data, which is what the user expects. If the software is actively changing too much, the user becomes confused and annoyed.
  Consider the screen pointer. Moving the screen pointer is a hand-eye coordination process. When the user learns to use the mouse or touch screen. Moving the pointer becomes reflex, which is more controlled by "muscle memory" than by "perceptual consciousness". The user's consciousness is free to consider their task. The software's automatic, unilateral move pointer destroys "hand-eye" coordination, causes confusion and pulls the user's consciousness back into the work of controlling the pointer. Users cannot determine which pointer movement actions are the result of their behavior, and which are the actions of the computer.
  This principle can be extended to screen pointers, windows, and controls. Includes desktop icons, item lists, and other types of data that people manipulate. The software should avoid "help" users re-layout their data. It should allow users to schedule and manage their own data.
  　　
  7.3 Maintain display inertia
  Closely related to the "screen belongs to the user" principle is the "show inertia" principle.
  When the software changes a display to show the effect of user action, it should try to minimize the content it changes. Local small data changes should only be made on the screen to generate small, local changes. When the user changes something on the screen, you should keep the screen as much as possible.
  If the change in the display cannot be limited to the place where the changes actually occurred. Then it makes the user very confusing.

• Develop user awareness and understanding of changes.

• Minimize disruption to the ability of users to continue working.

8) Principle 8: Design should meet response needs
The vast amount of evidence accumulated over the past 40 years suggests that responsiveness (i.e. the ability of software applications to keep up with users and not allow them to wait) is the most important factor in determining user satisfaction. It is not only one of the most important factors, but the most important factor.
8.1 What is responsiveness
Responsiveness is related to performance, but they are different. Interactive software can be highly responsive, but performance may be low, it can also be low-responsiveness and high performance, and performance is measured in terms of the number of calculations per unit of time. Responsiveness is measured by whether a person's time is met (ultimately satisfaction).
8.2 Design should meet the responsiveness
To make the user aware of the responsiveness, the interactive software must:

• Respond instantly to user actions. Even if the answer needs to be a certain elbow.
• Let users know when the system is busy and when it is free.
• Allow users to perform other actions while waiting for the feature to complete
• Make the animation move smoothly and clearly.
• Allow users to discard older brother actions they do not want to perform
• Enables the user to determine how long the operation will take.

• Allow users to set their own pace of work whenever possible.

  Just like the software used to control an aircraft. Software that deals with people also needs to meet real-time constraints. The three constant t responses in human behavior set the necessary goals for the responsiveness of the computer system:

• 0.1 seconds: This is the sense boundary between the cause and effect of the event. If the software does not respond to the user's actions within 0.1 seconds, the causal perception is broken, and the user no longer sees the reaction as the result of his or her actions. Therefore, the buttons on the screen have a time of 0.1 seconds to show that they are clicked, otherwise the user will click again. If a user is dragging an object that lags behind the cursor for 0.1 seconds, the user will have trouble putting the object in place. HCI researcher Stuart Card will call the time limit of 0.1 seconds the perceptual "instantaneous". It is also the approximate limit for smoothing animations to be sensed: 0.063 seconds/FRAME (16 frames per second).

• 1 seconds: This is the approximate normal time interval value in the conversation. When the interval exceeds 1 seconds, in order for the dialogue to continue, one of the parties must say something, even if it is just a word like "mmm" or "aha". Similarly, the software has about 1 seconds to execute the user's requirements or show how long it takes; otherwise, the user loses patience. One second is the approximate minimum response time that people respond to emergencies, just as the driver reacts to a child's sudden rush to the front of the car. In human-computer interaction, when the information suddenly appears on the screen. It takes at least 1 seconds for the user to react.

• 10 seconds: In this approximate time unit. People often abandon plans or disrupt the execution of a large task. The card and his colleagues call it the "unit task" time constant, during which time. People can concentrate on one task at a time. Every 10 seconds or so, people will stop working. Re-estimate the status of the mission and the surroundings, relax or do something else. After 10 seconds, the user ends a unit task and then begins the next one. This time constant can be observed in a variety of jobs, such as editing in a text editor, entering a bill into the audit program, and executing a combat strategy while the aircraft is fighting. In human-computer interaction, for a file transfer or search of this "heavy" machine operation, 10 seconds is almost the user willing to spend time on the startup operation. If the task is not started during this time, the user will lose patience. The result itself can take a longer time (assuming that the progress feedback is provided).

  Description: A smooth animation can be perceived with a maximum frame interval of less than 0.1 seconds: actually 0.063 seconds (16 frames per second).
  When driving, the response to a sudden event is less than 1 seconds: it is actually 0.7 seconds.
  Finally, the 10-second time constant is the approximate value of several mental time constants between 5-30 seconds.
  These three time amounts are an approximate result of a large number of more precise time constants observed in people's perception, motion, and cognitive tasks. They are sufficient to guide the user interface design. Set them to 0.1 seconds, 1 seconds, and 10 seconds for ease of memory.

9) Principle 9: Find an error through a user trial and fix it
Most computer practitioners have heard the phrase "early testing, frequent testing". Although computer software and hardware have a variety of different kinds of testing. But this book is primarily about usability testing, which allows the target users of a product or service to try to understand what's wrong with their learning and use process. Such tests are especially important for determining the success of a design, which is to determine whether the design is more user-helpful than a hindrance.
9.1 Test results may even surprise experienced designers
developers may get unexpected results from usability testing. Sometimes such results can even surprise the user interface expert.
I often review the SOFTWARE PRODUCT or service's UI before the user tests it. A pre-review of the UI provides me with a lot of ideas. This includes how to design tests, what kind of problems to look for, and how to interpret the problems users will encounter. However, after performing the test almost always exposes some usability issues that I never expected.
For example, a company developed a software to analyze the performance of a server cluster. This software is able to draw graphs with the performance of the server cluster as a function of the number of concurrent users. The user can specify the type of graphic: bar, Linetype, and so on. The thumbnail represents the type of drawing that is currently selected. Surprisingly, the usability side test shows that many users use thumbnails that represent drawing types as actual data Graphics! So. Testing is always useful. We'll never know what to learn from the tests, but we will certainly learn something that will help improve the quality of the software.
9.2 Schedule Time to correct problems found in testing
of course, just testing the usability of a product or service is not enough. The developer must also provide time in the development schedule for correcting errors found in the test. Otherwise, what's the use of testing? The
9.3 test has two purposes: informational purposes and social purposes

• Informational Purpose: Usability testing information is well-known: finding user interface problems that lead to user difficulties and using the exact nature of the problem to make recommendations for improvement. Information purposes can be achieved through a wide range of testing and data collection methods. Some of these methods are expensive and time-consuming. Some methods are inexpensive and fast.
• Social Purpose: A) The social purpose of usability testing is at least as important as the informational purpose. It is used to convince developers that there are some design issues that have to be corrected. Developers often have conflicting feelings about revising suggestions. This is partly because of the time and effort involved, and partly because of the need to improve a design, meaning that the people who designed it did not work well. In order to achieve the social purpose of testing, the most effective way is to let developers watch ease of use testing. You can watch it in real time or watch a test video.
  b) Developers may be emotionally agitated when they see users experiencing software usage issues. So when developers watch the tests themselves, be sure to remind them to watch calmly.
  c) In addition to making sure that developers need to fix ease of use issues. There are other benefits of emphasizing the social purpose of usability testing. It also makes it easier for developers to accept the idea that "usability testing is an important development tool, not a way to evaluate GUI developers." Programmers who initially did not want to make easy-to-use tests tended to change their attitudes after watching some (painful) tests. In later projects, they actively asked for usability testing as a way to get feedback.

9.4 testing at different times and for different purposes
Many in the computer industry have a false understanding of usability testing, which they believe should be tested when a software product or tool is ready to be handed over. and to use the test facilities and equipment that are exhaustive. In fact, usability testing has several ways, each with its pros and cons.
Ease-of-use testing can be categorized in two separate dimensions: 1 The point in time of execution of the test in development, and 2) the formal level of the test method. Tests can be done before any code has been written, and can be done only when some of the software is implemented. It can also be done after the software is almost complete.
The test method can be informal, quasi-formal, or formal. Interviews, surveys, natural observation and field studies are all "informal". Tests that users perform mandated tasks and collect qualitative and T-data in tests are called "quasi-formal". The main measure of quantitative data and the need for statistical analysis (usually compared to different designs) is "formal". Each implementation phase and formal degree can be arbitrarily combined.

9 Principles of GUI design (first article):
http://blog.csdn.net/sanqima/article/details/45598999
GUI Design 9 Principles (second article):
http://blog.csdn.net/sanqima/article/details/45601815

Translated literature: Jeff Johnson. GUI Bloopers 2.0 Common User Interface Design Don ' ts and Dos. 2009

9 Principles of GUI design (third article)