Objectives:
- Understand course policies and goals
- Get an overview of usability and its importance
- Begin to observe examples of good and bad interface design in the web pages and applications that you use
- Learn about simple panel and component layout using Java Swing
Programming Topic: Introduction to programming environment
Case Study: Two-photo organizer
Reading:
- SP: Chapter 1
- Core I: Chapter 7, pages 245-260
Quote:
user /n./
-
Someone doing `real work' with the computer, using it as a means rather than an end. Someone who pays to use a computer. See real user.
- A programmer who will believe anything you tell him. One who asks silly questions. [GLS observes: This is slightly unfair.
It is true that users ask questions (of necessity). Sometimes they are thoughtful or deep.
Very often they are annoying or downright stupid, apparently because the user failed to think for
two seconds or look in the documentation before bothering the maintainer.] See luser.
- Someone who uses a program from the outside, however skillfully, without getting into the internals of the program.
One who reports bugs instead of just going ahead and fixing them.
The general theory behind this term is that there are two classes of people who work with a program:
there are implementors (hackers) and lusers. The users are looked down on by hackers to some extent
because they don't understand the full ramifications of the system in all its glory. (The few users who do are known as `real winners'.)
The term is a relative one: a skilled hacker may be a user with respect to some program he himself does not hack.
A LISP hacker might be one who maintains LISP or one who uses LISP (but with the skill of a hacker).
A LISP user is one who uses LISP, whether skillfully or not.
Thus there is some overlap between the two terms; the subtle distinctions must be resolved by context.
-- The New Hacker's Dictionary
Administrative details:
- Go over syllabus and grading policy
- Class web page
- Teamwork
- General class schedule
- WebCT
- Accounts - make sure that your accounts work in all three labs
- Development environment (Eclipse, Visual Paradigm)
- Look at the Java documentation
Java 1.5.0 Documentation
Course themes:
- The interface is the computer.
Users develop an internal working model of the software
they use from their interaction with the
software's interface. (In other words, users
can not separate what the interface can do from the
capabilities of the software.)
- Interface design should be based on
how the software is used.
Usage-centered
design methodology makes software use
the central design issue.
- Implementation matters
Software use changes and evolves.
No matter how good the interface is and how well
it supports the use for which it was originally
designed, software will not be maintainable
if the underlying implementation is not clean
(exhibits high cohesion, low coupling).
What is usability?
- Achieve required performance
- Minimize time to learn and required skills
- Achieve required reliability
- Promote standardization, integration, consistency, and portability
Standardization: use pre-existing industry standards where they exist to aid learning and avoid errors (e.g. the W3C and ISO standards)
Integration: the product should be able to run across different software tools and packages (e.g., Unix, Windows, MacOS)
Consistency:
- Compatibility across different product versions
- Compatibility with related paper and other non-computer based systems
- Compatibility of actions within the program by using common action sequences, terms, units, colors, etc.
Portability: allow for the user to convert data across multiple software and hardware environments
Here are some other definitions:
Usability measures:
- Time to learn
- Speed of performance
- Rate of errors by users
- Retention over time
- Subjective satisfaction
Universal usability: Use by anyone, anytime, anywhere....
What are the barriers to universal usability?
- Device limitations
- Physical abilities
- Physical workplaces
- No average user in terms of physical dimensions
- Physical dimensions don't account for dynamic measures such as reach, strength or speed
- Individual preferences for items such as screen-brightness vary substantially
- User sensory abilities vary dramatically
- Vision: depth, contrast, color blindness, and motion sensitivity
- Touch: keyboard and touchscreen sensitivity
- Hearing: audio clues must be distinct
- User cognitive abilities and learning styles influence effectiveness in using an interface
- Long-term and semantic memory
- Short-term and working memory
- Problem solving and reasoning
- Decision making and risk assessment
- Language communication and comprehension
- Search, imagery, and sensory memory
- Learning, skill development, knowledge acquisition and concept attainment
- Confounding factors affecting perceptual and motor performance:
- Arousal and vigilance
- Fatigue and sleep deprivation
- Perceptual (mental) load
- Knowledge of results and feedback
- Monotony and boredom
- Sensory deprivation
- Nutrition and diet
- Fear, anxiety, mood, and emotion
- Drugs, smoking, and alcohol
- Physiological rhythms
- Cultural and international diversity are important
- Characters, numerals, special characters, and diacriticals
- Left-to-right versus right-to-left versus vertical input and reading
- Date and time formats
- Numeric and currency formats
- Weights and measures
- Telephone numbers and addresses
- Names and titles (Mr., Ms., Mme.)
- Social-security, national identification, and passport numbers
- Capitalization and punctuation
- Sorting sequences
- Icons, buttons, colors
- Pluralization, grammar, spelling
- Etiquette, policies, tone, formality, metaphors
- There are special populations
- Users with disabilities
- Elderly users
- Children
An example of usability guidelines:
http://web.mit.edu/ist/usability/usability-guidelines.html
Techniques to insure usability in the design process:
- Requirements phase:
- User profiles
- Task analysis
- Platform capabilities/constraints
- Design principles
- Usability goals - qualitative/quantitative
- Create Style Guide
- Design/Develop phase
- Iterative conceptual model design (paper prototypes)
- Usability test with prototype mockups
- Iterative screen design standards
- Usability test with prototype mockups
- Revise style guide
- Build/refine phase
- Usability test
- Evaluate/iterate - Usability goals met?
- Install phase
- User feedback
- Enhancements
- Usability test
- Next release
More details about methods can be found at
Usability Methods Toolbox
It is easier to find examples of bad design then to construct a good design...see for example:
Exercise 1: Open MS PowerPoint and evaluate the basic layout and workflow. Find the following
components:
- Button
- Textbox
- Textarea
- Label
- Checkbox
- Radio buttons in a button group
- Combo box
- Panel
- Split pane
- Scroll pane
- Tabbed pane
- Toolbar
- Dialog
- Menu item
- Menu bar
- File chooser
- Color chooser
- Tooltip
- Tree
Exercise 2: Evaluate the layout of the print dialog in PowerPoint
Exercise 3: Use Eclipse to write a Hello World application.
Case Study: Photo viewer
We will develop a simple application that displays a picture with an settable title.
learn about layout, about event management and the elements of design.
We will be using Java Swing components for building our interfaces. You should
bookmark the
Java Swing Tutorial for
examples of how to use different Swing components.
Exercise: Write a program which displays one of two images depending on which button is pressed:
- Frame
- Title
- Default closing
- Making frame visible
- Setting a default size
- Panel
- Putting a button in panel
- Using the border layout
- Displaying an image
- Adding events to do the action
- Discussion of the observer design pattern
- Four different ways of organizing events:
- Frame as listener
- Anonymous classes
- Separate inner classes
- With a controller using the model-view-controller design pattern (MVC)
- Using tooltips
- Using a simple menu
For testing purposes, download the following images into the resources subdirectory of your
photodisplay:
Event handling in GUIs are based on the observer design pattern.
Example: High-level component events in Java (such as button pressed) are represented by the ActionEvent:
- Subjects that have these events implement the
addActionListener and removeActionListener,
which correspond to attach and detach, respectively.
- Observers of these events must implement the
ActionListener interface which just has the actionPerformed
method.
For a full list of the standard design patterns, see:
Design Pattern Mattrix from
Net Objectives.
For Monday: BRING TO CLASS. You should make a copy of these. You will hand in the copy at the beginning
of class. We will then discuss and work with partners on some aspects of this.
- Write a five to ten line problem statement describing the slide show application
- Draw an initial mockup of your slide show application
- Write an initial step-by-step procedure (in sentence format) for the simplest, most common use
of your application.