第1页 / 共241页
第2页 / 共241页
第3页 / 共241页
第4页 / 共241页
第5页 / 共241页
第6页 / 共241页
第7页 / 共241页
第8页 / 共241页
SSD4 用户界面设计 pdf.pdf
[Trial version] SSD4
[Trial version] Unit 1
[Trial version] 1.1 Foundation for User-Centered Design and Testing
[Trial version] 1.1.1 Iterative Design
[Trial version] 1.1.2 Basic Concepts of Interactive Programming
[Trial version] 1.1.3 Basic Psychology Needed for Interface Design
[Trial version] Exercise 1
[Trial version] 1.2 A Tool for Creating User Interfaces: Visual Basic
[Trial version] 1.2.1 The Visual Basic Programming Environment
[Trial version] 1.2.2 Writing Visual Basic Code
[Trial version] 1.2.3 Debugging Visual Basic
[Trial version] Exercise 2
[Trial version] 1.3 Tools for Evaluating Usability: Heuristics and Think-Aloud Testing
[Trial version] 1.3.1 Basic Heuristic Evaluation1
[Trial version] 1.3.2 Basic Think-Aloud Usability Testing
[Trial version] 1.3.3 How to Write a Usability Aspect Report (UAR)
[Trial version] Unit 2
[Trial version] 2.1 Creating with Labels, Shapes, and Lines ¡ª Evaluating with Two Heuristics
[Trial version] 2.1.1 Labels, Shapes, and Lines
[Trial version] 2.1.2 HE: Match Between System and the Real World
[Trial version] 2.1.3 HE: Visibility of System Status
[Trial version] Exercise 3
[Trial version] 2.2 Creating with Buttons ¡ª Evaluating with Three Heuristics
[Trial version] 2.2.1 Buttons
[Trial version] 2.2.2 HE: Consistency and Standards
[Trial version] 2.2.3 HE: User Control and Freedom
[Trial version] 2.2.4 HE: Flexibility and Efficiency of Use
[Trial version] Exercise 4
[Trial version] 2.3 Creating with Checkboxes and Radio Buttons ¡ª Evaluating with One Heuristic
[Trial version] 2.3.1 Checkboxes and Radio Buttons
[Trial version] 2.3.2 HE: Error Prevention
[Trial version] 2.4 Creating with ListBoxes and ComboBoxes ¡ª Evaluating with One Heuristic
[Trial version] 2.4.1 ListBoxes and ComboBoxes
[Trial version] 2.4.2 HE: Aesthetics and Minimalist Design
[Trial version] Exercise 5
[Trial version] 2.5 Creating with Combinations
[Trial version] 2.5.1 UpDown and Scrollbar Controls
[Trial version] 2.5.2 TextBox Controls
[Trial version] 2.6 Creating with Containers ¡ª Evaluating with One Heuristic
[Trial version] 2.6.1 Frame Controls
[Trial version] 2.6.2 Tabbed Dialog Controls
[Trial version] 2.6.3 HE: Recognition Rather than Recall
[Trial version] 2.7 Two More Heuristics for Evaluating Interfaces
[Trial version] 2.7.1 HE: Help and Documentation
[Trial version] 2.7.2 HE: Help Users Recognize, Diagnose, and Recover from Errors
[Trial version] Exercise 6
[Trial version] 2.8 Menu Controls and Some Example UARs
[Trial version] 2.8.1 Menu Controls
[Trial version] 2.8.2 Example UARs
[Trial version] Unit 3
[Trial version] 3.1 Basic Issues in Think-Aloud Testing
[Trial version] 3.1.1 What Is Think-Aloud Usability Testing?
[Trial version] 3.1.2 Ethics for Empirical Studies
[Trial version] 3.2 How to Conduct a Think-Aloud Usability Test
[Trial version] 3.2.1 Defining the Study's Framework
[Trial version] 3.2.2 Choosing What to Observe
[Trial version] 3.2.3 Preparing for the Observation
[Trial version] 3.2.4 Introducing Participants to the Procedure
[Trial version] 3.2.5 Conducting the Observation
[Trial version] 3.2.6 Analyzing the Observation
[Trial version] 3.2.7 Finding Possible Redesigns
[Trial version] 3.2.8 Writing a Summarizing Report
[Trial version] Exercise 7
[Trial version] 3.3 Think-Aloud Testing vs. Heuristic Evaluation
[Trial version] 3.3.1 Comparing Heuristic Evaluation with Think-Aloud Usability Testing
[Trial version] Unit 4
[Trial version] 4.1 Object Placement and Drawing
[Trial version] 4.1.1 Coordinate Systems and Object Placement
[Trial version] 4.1.2 Drawing Primitives
[Trial version] Exercise 8
[Trial version] 4.2 Adding Interactivity and Undo
[Trial version] 4.2.1 Adding Interactivity to Drawing
[Trial version] 4.2.2 Implementing Undo
###E###
###E###
###E###
ABC Amber CHM Converter Trial version, http://www.processtext.com/abcchm.html
It's hard enough to build something once; how can we afford to build things more than once?
1.
2. How do we accumulate experience and get feedback from users in a way that yields useful
guidance to further work?
The key to answering the first question is to adopt a rapid prototyping approach. The idea is to
implement enough of a design to allow testing, without committing the effort needed to create a complete
product. For example, one might mock up the various displays seen by a user, without writing all of the
code required to create them and navigate among them. Or, one might write code that works for just a
single execution case, limiting the choices available to a user at any time. Once user feedback is obtained
for the aspects of a system that have been prototyped, design choices for those aspects can be narrowed
down, and other aspects can be prototyped and tested.
The answer to the second question requires a body of knowledge and technique. Good user testing
relies on some knowledge of human psychology— and on good techniques for eliciting, recording, and
analyzing user feedback.
This course provides you with three important tools of iterative, user-centered design: user interface
programming in Visual Basic, heuristic evaluation of user interfaces based on accumulated design
experience, and empirical think-aloud usability testing.
Visual Basic
Visual Basic is one of the most popular programming languages in use today, especially in the area of
user interfaces. As you will see, it supports rapid prototyping of user interfaces, making it possible to test
many aspects of a system's usability before its implementation is complete. Once you have learned to use
Visual Basic, you will also be able to apply this approach to other languages and systems.
Heuristic Evaluation
Heuristic evaluation is a process that designers use to estimate the usability of their designs prior to
submitting them to actual user testing. In this context, the word heuristic means a general principle or
"rule of thumb" that usually leads to a good answer. In this course, you will learn a small set of heuristics
that will help you to make good user-interface design decisions, and also learn how to apply them in your
work.
Think-Aloud Studies
The think-aloud approach is a powerful method empirically evaluating the usability of a system. In this
method, a user is presented with a system or prototype and asked to perform a task while "thinking
aloud" the steps and decisions involved. The collection and analysis of think-aloud data requires a
disciplined approach, which you will learn in this course.
Used together, these three tools will help you to design usable and successful systems
Page 4
###E###
ABC Amber CHM Converter Trial version, http://www.processtext.com/abcchm.html
Figure 1: Knurling provides affordance for gripping.
Figure 2: Simulated knurling invites the user to "grip" with the mouse.
Because most objects in a graphical user interface appear only as pictures on a screen, the physical
affordances that they can offer are limited. However, by properly manipulating the visual appearances of
objects, we can still make the purpose, state, and opportunities for action associated with objects
apparent to the user. This provides what might be thought of as a virtual affordance. For example, while
we cannot knurl objects on the screen, we can provide simulated knurling as illustrated in Figure 2.
Here we see the "resize handle" in the corner of a window in the Microsoft Windows standard user
interface. It appears to have raised ridges much like a knurled surface. As a result, it reminds us of the
affordance for grip found in the physical world, and hence invites us to act using the graphical user
interface analog of grip (pressing and holding the mouse button over the area, in preparation for
dragging). Since the ridges are oriented diagonally, this in particular invites us to "grip" and drag towards
the southeast— which is appropriate for resizing a window. Note that we don't have to understand what
knurling is, or that it affords grip, in order for this appearance to be effective as an affordance for "grip" in
the interface. It can be effective simply because it reminds us of our past experience with many real
world objects.
By manipulating the visual appearance of objects to provide proper affordances (or technically, to remind
the user of affordances from their past experience, which typically has the same practical effect), we
make the operation of interfaces more apparent, and we reduce the effort needed to learn them and
perceive their important properties. As a general rule (which we will see later in the form of a usability
heuristic) a good user interface design will provide some visual indication of (affordance for) the actions
that the user can carry out with it.
The important concept of feedback has a conceptually similar purpose. Feedback is the response by the
system to the actions of the user. This often comes in the form of updated visual representations, but can
also be provided in other modalities such as audio. If a system provides immediate feedback that clearly
indicates the nature and consequences of their actions, it is much easier for users to evaluate whether
those actions are having the desired effect. In the physical world, we normally get direct and strong
feedback about the objects we manipulate in the form of vision, touch, and sound. In the virtual world,
however, such strong and immediate feedback is often lacking because computational actions are
Page 6
###E###
ABC Amber CHM Converter Trial version, http://www.processtext.com/abcchm.html
of the same program that use different windows) can have the illusion of directly drawing on their own
display device. This makes drawing code easier to create and allows many independent programs (or
parts of the same program) to share the limited resources of a single display device gracefully.
Inputs in modern interactive systems are generally modeled as input event records (often just simply
events). Such an event record is a record of some significant action. The most common events record
changes in the state of input devices (resulting from user manipulation of the devices)— for example,
pressing a keyboard key or moving the mouse. However, other kinds of event records are also possible,
such as those recording the arrival of data on a network connection. Events may record information such
as what happened, when it happened, the context of important input devices at the time of the event (for
example, where the mouse was pointing when it happened, and the status of various modifier keys, such
as SHIFT and CTRL). Finally, events record any data associated with the input (such as the character
value associated with a key press event).
Since it is possible for events to be generated by the user faster than the program can respond to them,
event records are normally placed in a queue to ensure they are not lost. Programs operate by
requesting the next event from the input queue, interpreting and processing that event, producing any new
output that is needed as a result (for example, redrawing the screen), and then returning for the next
event. If there are no events currently waiting in the input queue, the program normally simply waits for
the next event to arrive. By modeling all "significant actions" of interest to an interactive program as
events (even things such as interprocess communications and asynchronous file I/O), it is possible to
support various forms of asynchronous input together using only the control flow outlined above.
Controls, Model Objects, and Interpreting Events
Given the basic event/redraw cycle described above, the central question becomes one of how to
actually interpret and respond to incoming events, and how to structure the output creation process.
While it is possible to write code that directly responds to events and directly draws as a result, most
interactive programs written today (including the ones you will write in Visual Basic) make use of a
toolkit to support these operations. A toolkit provides a much higher-level abstraction of the
event/redraw cycle and automates a number of important steps. In particular, toolkits provide a reusable
library of objects that can appear on the screen and be the target of user input. Examples of such objects
include the buttons, sliders, text areas, icons, check boxes, and menus familiar to most users. These
objects are sometimes called widgets, interactors, or interactive components. In Visual Basic and
several other systems, these objects go by the name of controls. One of the major benefits of using a
toolkit is that it provides a rich set of such controls and allows new types of controls to be created when
necessary. This means that a programmer does not necessarily need to recreate, for example, a button
control, and that all button controls the user sees will work in the same way.
In direct manipulation terms, controls provide a presentation of the objects of interest to users.
However, because controls come from a generic library, they do not generally support the detailed
semantics of those objects. For example, in an interface to set the time, a text entry control can represent
minutes. However, the standard text entry control does not have anything built into it that recognizes the
fact than the minute value must be an integer between 0 and 59. In addition, it is often the case that one
object of interest is represented to the user by several different controls. For example, when providing
an interface to minutes, it might be convenient to provide both a text entry control and a set of arrows
(what we will later see is an "up-down" control) to increment or decrement the value as shown in Figure
3.
Page 8
相关推荐
2023年江西萍乡中考道德与法治真题及答案.doc
2012年重庆南川中考生物真题及答案.doc
2013年江西师范大学地理学综合及文艺理论基础考研真题.doc
2020年四川甘孜小升初语文真题及答案I卷.doc
2020年注册岩土工程师专业基础考试真题及答案.doc
2023-2024学年福建省厦门市九年级上学期数学月考试题及答案.doc
2021-2022学年辽宁省沈阳市大东区九年级上学期语文期末试题及答案.doc
2022-2023学年北京东城区初三第一学期物理期末试卷及答案.doc
2018上半年江西教师资格初中地理学科知识与教学能力真题及答案.doc
2012年河北国家公务员申论考试真题及答案-省级.doc
2020-2021学年江苏省扬州市江都区邵樊片九年级上学期数学第一次质量检测试题及答案.doc
2022下半年黑龙江教师资格证中学综合素质真题及答案.doc
