9 principles of GUI Design (article 3) and 3 of gui Design 9

9 principles of GUI Design (article 3) and 3 of gui Design 9

Basic Principle 7: transfer information, not just data
Basic Principle 8: The design should meet the response needs
Basic Principle 9: discover an error through a user trial and fix it

7) Principle 7: transfer information, not just data
The computer promises a source of information. But they mainly transmit a large amount of data ...... Most of them are useless data. Data is not information. People need to extract information from the data.
Software applications generally regard data as information. They throw data to you and let you find out what they mean. Software should focus users' attention on important data and help them extract information from it.
7.1 carefully design the display and obtain professional help
Kimu Principle 2 mentioned: "first consider the function. ", But in any software development work, we sometimes have to consider how to represent the control and status of the software while also considering the user data. In this case, the designer should carefully consider the screen design. Our goal is:

• Visual sequence and user focus: Successful user interface design is not just a simple representation. It redirects users' attention to important content.
• Easy to browse: computer users seldom read the screen carefully; they usually browse quickly to find information that matches their goals. Therefore, the screen must be designed to be easy to browse. Do not use large text segments. You need to divide the information into titles, highlights, lists, and tables. Use graphs to display information wherever possible. The link tag must be short.
• Matching media: one feature of poor user interface design is that the design does not match the limitations of the representation media. Well-designed user interfaces can match the media they use.

• Note details: success lies in details. This is especially true in the Design of Information Representation. Hiring user interfaces and graphic designers may seem costly, but they can easily pay off the costs of hiring other developers who are less likely to pay attention to the details. When programmers must work without the support of design experts, they should at least arrange the design of the user interface to detail-oriented personnel. Otherwise, many GUI defects or errors may occur in the product. For example, inconsistent display, design inconsistency, unidentifiable symbols, and overall unprofessional appearance may impede product success.

  7.2 screens belong to users
  The valid GUI principle is "the screen belongs to the user ". The graphic user interface is based on the user's direct data operations, which is expected by the user. If the software changes too much, the user will become confused and worried.
  Consider the Screen Pointer. Moving the Screen Pointer is a process of hand-eye coordination. After a user learns to use a mouse or touch screen, the pointer is moved to a reflection, that is, it is more controlled by the "muscle memory" instead of the "consciousness. Users are free to consider their tasks. The automatic and unilateral movement of the software destroys the coordination of the "hand-eye", causing confusion and pulling the user's consciousness back to the work of controlling the pointer. Users cannot determine which pointer movement operations are the result of their actions and which are computer operations.
  This principle can be extended to screen pointers, windows, and controls, including desktop icons, project lists, and other types of data operated by people. The software should avoid "helping" users to rearrange their data. It should allow users to arrange and manage their own data.
  　　
  7.3 keep display inertia
  Closely related to the "screen belongs to the user" principle is the "display inertia" principle.
  When the software changes a display to show the effect of user operations, it should try to minimize the content it changes. Small local data changes should only generate small and local changes on the screen. When a user changes something on the screen, the screen should be kept unchanged as much as possible.
  If you cannot restrict the changes in the display to the actual changes. This will make users very confused.

• Cultivate users' cognition and understanding of changes.

• Minimize damage to the user's ability to continue working.

8) Principle 8: The design should meet the response needs
A large amount of evidence accumulated over the past 40 years shows that responsiveness (that is, the ability of software applications to keep up with users without waiting) is the most important factor in determining user satisfaction. It is not only one of the most important factors, but also the most important factor.
8.1 what is responsiveness
Responsiveness is related to performance, but they are different. Interactive Software may have high responsiveness, but the performance may be low. It can also have low responsiveness and high performance, measured by the amount of computing per unit of time. Responsiveness is measured based on the time when the person meets the requirement (ultimately satisfaction.
8.2 design should meet responsiveness
To make users aware of responsiveness, interactive software must:

• Responds to user operations in real time, even if the response needs to be answered.
• Let users know when the system is busy and when it is idle.
• Allow other operations while waiting for function completion
• Make the animation smooth and clear.
• Allow users to give up operations they do not want to perform
• This allows you to determine how much time the operation will take.

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

  Just like software used to control aircraft. Software dealing with people also needs to meet real-time constraints. The three common t values reflected in human behavior set a required goal for computer system responsiveness:

• 0.1 seconds: This is the perceived boundary between the cause and effect of an event. If the software does not respond to the user's actions within 0.1 seconds, the causal perception is broken. The user no longer regards the displayed response as the result of his/her actions. Therefore, the buttons on the screen have 0.1 seconds to show that they have been 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 be in trouble when placing the object. HCI researcher Stuart Card calls the 0.1-Second time boundary as an "instant" of perception ". It is also an approximate boundary for a smooth animation to be perceived: 0.063 seconds/frame (16 frames/second ).

• 1 second: This is the approximate normal interval value in the dialog. When the interval exceeds one second, one party must say something to keep the conversation going, even if it is just a word like "hmm" or "aha. Similarly, the software has a requirement of about 1 second to execute the user, or shows how long it takes; otherwise, the user will lose patience. One second is also the approximate minimum response time for people to respond to emergencies, just like the response that a driver suddenly jumps to a car. In human-computer interaction, information suddenly appears on the screen. It takes at least one second for the user to respond.

• 10 seconds: In this approximate time unit. People often give up their plans or interrupt the execution of a large task. Card and his colleagues call it a "unit task" time constant during this period. People can concentrate on a single task. Every 10 seconds or so, people stop working. Re-estimate the task status and surrounding environment, relax or do something else. After 10 seconds, the user will end a unit task and start the next one. This time constant can be observed in all kinds of work, for example, you can edit a task in a text editor, input a bill to the audit program, and execute a combat policy during air combat. In human-computer interaction, for file transmission or search for such "heavy" computer operations, 10 seconds is almost the time the user is willing to start the operation. If the task has not started yet, the user will lose patience. The computing result itself can take a longer time (assuming that progress feedback is provided ).

  Note: The maximum frame interval that a smooth animation can perceive is less than 0.1 seconds. The actual interval is 0.063 seconds (16 frames/second ).
  The response speed to an emergency during driving is less than 1 second: Actually 0.7 seconds.
  Finally, the constant of 10 seconds is in the range of 5 ~ Approximate values of several psychological Time Constants Between 30 seconds.
  These three time periods are an approximate result of a large number of more precise time constants observed in people's perception, movement, and cognitive tasks. They are enough to guide the user interface design. They are set to 0.1 seconds, 1 second, and 10 seconds to facilitate memory.

9) Principle 9: Identify an error through a user trial and fix it
Most computer practitioners have heard the phrase "early test and frequent test. Although computer software and hardware have different types of tests. However, this book mainly involves usability testing, that is, testing the target users of products or services to learn what problems they have in learning and using. This test is especially important to determine whether the design is successful, that is, to determine whether the design is more helpful to the user than the obstacle.
9.1 The test results may even surprise Experienced designers
Developers may obtain unexpected results from usability tests. Sometimes this result may even surprise the user interface experts.
I often review the UI of software products or services before conducting user tests. Pre-Review of the UI provides me with a lot of ideas. This includes how to design tests, find out which types of problems, and explain the problems that users will encounter. However, after the test is executed, some usability problems that I did not expect will almost always be exposed.
For example, a company develops a software program to analyze the performance of a server cluster. This software can plot the performance of the server cluster as a function of the number of concurrent users. You can specify the chart type, such as bar chart and line chart. Thumbnail indicates the selected drawing type. Surprisingly, the usability side-test shows that many users regard thumbnails used to represent the drawing type as actual data graphics! Therefore. Testing is always useful. We will never know what we will learn from testing, but we will certainly learn something that will help improve the quality of software.
9.2 schedule the time to correct the problems found during the test
Of course, it is not enough to test the usability of products or services. Developers must also provide time in the development schedule to correct errors found in the test. Otherwise, what is the purpose of the test?
9.3 The test has two purposes: information purpose and social purpose

• Information Purpose: The purpose of usability testing is well known: to find the user interface problems that lead to user difficulties, and to use the correct nature of the problem to propose improvement suggestions. Information can be achieved through extensive testing and data collection methods. Some of these methods are expensive and time-consuming, while others are cheap and fast.
• Social purpose: a. The social purpose of usability testing is at least as important as that of information. It is used to convince developers that there are some design issues that need to be corrected. Developers often have resistance to modification suggestions. This is partly due to the time and effort required, and partly because a design needs to be improved, which means that the design personnel did not do well in their original work. To achieve the social purpose of testing, the most effective way is to let developers watch usability testing. You can watch or watch test videos in real time.
  B) Developers may be excited when they see software usage problems. Therefore, when developers watch the test in person, they must be reminded to watch it calmly.
  C) In addition to ensuring that developers need to fix usability issues. There are other benefits that emphasize 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 are initially reluctant to perform usability tests tend to change their attitudes after watching some (painful) tests. In subsequent projects, they actively requested usability testing as a way to get feedback.

9.4 conduct tests at different times for different purposes
Many people in the computer industry have an incorrect understanding of usability testing, and they believe that testing should be conducted when software products or tools are about to be ready for transfer. Comprehensive test facilities and equipment should be used. In fact, there are multiple ways to test usability, each of which has its own advantages and disadvantages.
Usability tests can be categorized by two independent dimensions: 1) time points for testing in development; 2) degree of formality of the test method. The test can be performed before any code is written, and only when some 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 on-site research are "informal ". A test in which a user executes a specified task and collects qualitative and t-based data in the test is called "quasi-formal ". The research that mainly quantifies data and requires statistical analysis (usually comparing different designs) is "formal ". Each implementation phase and degree can be combined at any time.

9 principles of GUI Design (Article 1 ):
Http://blog.csdn.net/sanqima/article/details/45598999
9 principles of GUI Design (Article 2 ):
Http://blog.csdn.net/sanqima/article/details/45601815

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