All Files in ‘COSC368 (2021-S2)’ Merged

01. Introduction to Human-Computer Interaction

Andy Cockburn: Room 313, working Thursdays and Fridays

Tutors: team368@cosc.canterbury.ac.nz

Course breakdown:

Goals:

HCI: discipline concerned with the design, evaluation and implementation of interactive computing systems for human use.

There should be a cycle of evaluating, designing and implementation.

Usability

Three key pillars:

Two minor pillars:

Trade-offs: efficiency and learnability (inverse of time spent) are often at odds with each other. The performance/efficiency ceiling is often lower for more learnable interfaces.

Preliminary Factors

Usability is like oxygen: you only notice it when it’s absent. See: doors with handles that you need to push.

Managing Complexity

The job of HCI is to manage complexity: designing an object to be simple and clear; the relentless pursuit of simplicity.

Interface
Complexity
    ^
    |                                              ____
    |                                         ____/
    | Poorly designed                    ____/
    | UIs; complexity               ____/
    | amplified                ____/
    |                     ____/     Well designed UIs
    |                ____/
    |           ____/
    |      ____/
    | ____/
    |/
    +--------------------------------------------------> Domain
     Door      Word        CAD          Nuclear          Complexity
             Processor                power plant

Models

Models are simplifications of reality that (should) help with the understanding of a complex artifact.

Don Norman’s Model of Interaction

From ‘The Psychology/Design of Everyday Things’, 1988.

This helps understand the designer’s role in creating a system that is used by a thinking person.

               constructs
   Designer/ -------------> System/system image
designer model                ^
                    Provides  | Provides input based on
                    feedback/ | their prediction of how
                     output   |  to achieve their goal 
                              v
                             User/
                          user model

The designer tries to construct a system that they have not fully defined. The designer’s model is their conception of interaction; often incomplete, fuzzy or compromised in the actual implementation.

System image: how the system appears to be used (by the user); this does not necessarily reflect the truth of the system.

The user’s model begins very weak, coming from familiarity with the real world or other similar systems. They will use this experience to try and interact with the user system, building their model based on feedback from the system.

Ideally, there should be conformance between the designer and user’s model.

There is no direct communication between the designer and user; the designer can only communicate with the user through the system.

Execute-Evaluate Cycle

Execute:

Evaluate:

UISO Interaction and Framework

Abowd and Beale, 1991.

User, System, Input and Output.

Emphasizes translation during interaction:

User has some low level task (e.g. saving a file); they need to translate their intention to an input language; this is one of the most difficult parts of user interface design.

              --> Output ---
Presentation /              \ Observation
            /                \
           /                  v
    System                      User
    (Core)                      (Task)
           ^                  /
Performance \                / Articulation
             \--- Input <---/

Mappings

Good mappings; the relationship between controls and their effects, increase usability.

Affordances

Objects afford particular actions to users; there is a strong correlation between how it looks like it should be used and how it is used:

Poor affordances encourages incorrect actions, but strong affordances may stifle efficiency.

Over-/Under-determined Dialogues

Beginner user interface designers tend to think about the interface in terms of system requirements: the system needs x, y, z information so lets ask the user about these things up-front. These over-determined dialogues lead to horrible design.

Direct Manipulation

Advantages:

Disadvantages:

The Human

Fun Example

A trivial task that many humans will get wrong.

Count the number of occurrences of the letter ‘f’ given a set of words:

Finished files are the results of years of scientific study combined with the experience of many years

Three phonetics Fs: ‘finished’, ‘files’, ‘scientific’, are easily found.

But three non-phonetic Fs in ‘of’ are often forgotten.

Click

Even a blank graphic has affordances on where people usually click: on or near the center, or along the diagonals or corners.

Human Factors

Psychological and physiological abilities hae implications for design:

The Human Information Processor

Card, Moran, Newell 1983.

               Eyes/Ears
                   │
                   ▼
    ┌──── Perceptual Processor ────┐
    │                              │
    ▼                              ▼
Visual Image ──────┬─────── Auditory Image
 Storage           │           Storage
                   │
                   ▼
      ┌─────Working Memory ◄─────────┐
      ▼                  ▲           ▼
    Motor                │        Long-Term
  Processor              │         Memory
      │                  │           ▲
      |                  |           |
      ▼                  │           ▼
  Movement               └──────► Cognitive
  Response                        Processor

Human Input

Vision

Cells:

Areas:

1 degree = 60 arcminutes, 1 arcminute = 60 arcseconds

Visual Acuity:

Eye movement:

Size/depth cues:

Muller-Lyer illusion:

 <->
>---<

Bottom one looks further away and is subtending the same angle, so brain perceives it as bigger.

3D, depth-based UIs:

Color:

Reading:

Auditory

Haptics

Haptic feedback: any feedback providing experience of touch

Human Output

Motor response time depends on stimuli:

Muscle actions:

Fitts’ Law

A very reliable model of rapid, aimed human movement.

Index of difficulty (ID) measures difficulty of rapid aimed movement:

ID=log2(AW+1) \mathrm{ID} = log_2\left(\frac{A}{W} + 1\right)

Measured in ‘bits’.

Fitt’s law: movement time (MT) is linear with ID:

MT=a+b⋅ID=a+b⋅log2(AW+1) \begin{aligned} \mathrm{MT} &= a + b \cdot \mathrm{ID} \\ &= a + b \cdot log_2\left(\frac{A}{W} + 1\right) \end{aligned}

1/b1/b, the reciprocal of slope, is called throughput, or the bandwidth of the device in bits/second.

aa and bb are empirically determined. For a mouse:

Typical velocity profile, validated for many types of aimed pointing:

Speed 
  ^
  |   Open-loop,
  |balistic impulse
  |    /\
  |   /  \   slow, closed-loop
  |  /    \    corrections
  | /      \  /\
  |/        \/  \/\___
  +------------------------>
           Time

Input Devices; Pointing & Scrolling

Human output is received as system input. There must be some sort of translation hardware to achieve this, which have many properties:

The control-display transfer function:

                                 Transfer Function
        +-------------------------------------------------------------------------+
        |                                                     e.g. scroll inertia |
        | device   ---------------  display   --------          ---------------   |
Device -+--------> | Translation | ---------> | Gain |  ------> | Persistence | --+---> Output
Input   | units    ---------------   units    --------          ---------------   |
        |                ^                       ^                     ^          |
        |                ------- Environment/User Settings ------------           |
        +-------------------------------------------------------------------------+

Scrolling transfer function for iOS:

Input Devices: Text Input

Input expressibility: how well can you discriminate inputs? e.g. Google Glass had a tiny capacitive surface; doing text entry on that posed challenges.

Steering Law

Model of continuously controlled ‘steering’: moving an item across a given path, called a ‘tunnel’:

MT=a+b⋅AW\mathrm{MT} = a + b \cdot \frac{A}{W}

Where AA is the tunnel length and WW is the width. If the thickness varies, use the integral of the inverse of path width.

This is important in cascading context menus, where hovering over an item overs a submenu to the left or right. Done naïvely, while travelling to the newly-opened submenu, the cursor must always stay above the item or the submenu will disappear. macOS appears to take into account the angle of travel to determine if the submenu should be hidden or not.

Human Processing

Visual Search Time

If a person has to pick out a particular item out of nn randomly ordered items, the average time TT taken to find the item increases linearly: T=a+bn+12T = a + b \frac{n + 1}{2}. However, pop-out effects where one item is visually distinct, reduces this to O(1)O(1). However, this requires the interface to predict what the user wants to select.

This is slow, so the UI should aim to reduce the amount of searching the user must do. To achieve this, ensure there is spatial stability; items appear in the same place every time.

Hick/Human Law of Decision Time

Choice reaction time when optimally prepared:

T=a+b⋅H T = a + b \cdot H

Where HH is the ‘information entropy’; ∑inpiHi\sum_i^n{p_i H_i}

For item ii with probability pip_i of being selected:

Hi=log⁡2(1pi) H_i = \log_2 \left( \frac{1}{p_i}\right)

For nn equally probable items, H=log⁡2(n)H = \log_2(n).

Implications:

Spatially Consistent User Interfaces

Pie menu: items are sectors making up a circle centered around the cursor (possibly with multiple layers of items through nesting):

Ribbon: spatial stability within each tab, but requires visual search and mechanical interactions to find a new item. ‘Solution’: show all tabs at once.

Search: macOS menu bar search does not run searched command, only show you where the item is located. Menu items also show the keyboard shortcut.

Torus pointing: wraps cursor around screen, gives multiple straight paths to an item. Giving users choice may help with Fitts’ law, but increase decision time.

Power Law of Practice

Performance rapidly speeds up with practice:

Tn=Cn−α T_n = Cn^{-\alpha}

Where:

This applies both to simple and complex tasks.

Novice to Expert Transitions

People use the same tools for years/decades, but often continue to use inefficient strategies.

Shortcut vocabularies are small and are used infrequently. Factors:

How do you support transitions to experts?

When switching between modes, there is a performance dip. Since people use software to do their jobs, not use software as their jobs, this causes a chasm that the user must take the time to cross.

^  Performance          Modality
│                        Switch
│                          |                       xxxxx
│                                          xxxxxxxxx
│                          |           xxxxx
│                                   xxxx
│                          |      xxx
│                                xx
│                          |    xx
│                Ultimate     xxx
│              xxxxxxxxxxxx| xx  ─┐
│        xxxxxx Performance  x    │ Performance
│    xxxx                  |x     │    Dip
│   xx  Extended            x     │
│  x  Learnability         |x    ─┘
│ xx
│ x                        |
│x
│x Initial                 |
│Performance
│                          |
│     First Modality             Second Modality
└──────────────────────────-────────────────────────────>
                            Time
Domains of Interface Performance Improvement

Human Pattern of Behavior

Zipf’s Law: given a cohort of text, nnth most frequently occurring word appears with a probability of:

Pn≈n−α P_n \approx n^{-\alpha}

where α≈1\alpha \approx 1.

Pareto Principle/80-20 Rule: 80% of usage is made up of only 20% of items.

The UI should attempt to surface these 20% of items.

Human Memory

                         maintenance
                          rehearsal
                           ┌────┐
                           │    │
                           │    ▼       elaborative
  Sensory Memory          Short-term     rehearsal    Long-term
  iconic, echoic,──────►    memory    ──────────────►  memory
  and haptic                  │       ◄──────────────
       │                      │          retrieval
       │                      │
       │                      │
       │                      │
       │                      │
       ▼                      ▼
   masking decay       displacement or
                      interference decay

Sensory memory: stimulation decays over a brief period of time; loud noises, bright lights, pain persists for some time after the stimulation disappears.

Short-Term Memory

Long-Term memory

Human Error

Mistakes

Errors of conscious decisions; when they act according to their an incomplete/incorrect model.

Only detected with feedback.

Human Error: Slips

Errors of automatic and skilled behavior.

Capture error:

Description error:

Data-driven error:

Loss-of-activation error:

Mode error:

Motor slip:

Premature closure error:

Human Phenomena

Homeostasis

People maintain equilibrium:

Satisficing

People are satisfied with what they can do now and don’t bother to optimize:

Hawthorne Effect

The act of measuring changes results (Heisenburg uncertainty principle of HCI).

People like being involved in experiments and change their behavior during experiments, complicating results.

Explaining Away Errors

Blaming the user is often easiest party to blame, but the user may have the mistake because the interface is designed poorly.

Peak-End Effects

Peak effect: people’s memories of experiences are influenced by the peak/most intense moments of an experience (e.g. combos attacks in games, casino games).

End effect: people’s memories of experiences are predominantly influenced by the terminating moments (e.g. good vaccation ruined by missed flight home, survey with many questions on the last page).

Negativity Bias

Magnitude of sensation with loss greater than the same amount of gain: bad is stronger than good.

e.g. single coin toss, win $110 on heads but lose $100 on tails, autocorrect ‘correcting’ a correct word feels much worse than how good it feels when it corrects a mis-spelt word.

Communication Convergence

Similarity with pace, gestures, phrases, etc. enhances communication. Could interfaces measuring (e.g. long press duration, mouse speed) and matching (e.g. animation speed, timeout, speech rate) help?

02. Interface Design

Design -> Implementation -> Evaluation -> Design -> …

Design Process

Saul Greenberg

Articulate

Articulate:

Then design:

This should lead to user and task descriptions.

Then, evaluate the tasks and repeat the process, refining goals.

Brainstorm Designs

When designing, consider:

Create low-fidelity prototyping methods.

Then, create throw-away paper prototypes.

NB: ‘prototype’ has multiple meanings, one of which implies executability.

Evaluate the designs:

Repeat steps if required, further brainstorming more designs.

A reviewer should be able to unambiguously understand how the interface operates and works.

Refined Designs

Create:

Then use high-fidelity prototype methods and create testable prototypes.

Use usability testing and heuristic evaluation to further refine design if required.

Completed designs

Create alpha/beta systems or complete specifications. Do field testing if necessary.

Iterative Design

Iteratively refine design based on evaluative feedback.

A common mistake is to get an idea and hill climb on that single idea. Leads to:

Elaborative/Reduction Tension

Elaboration: get the Right Design; explore the full space of possible designs.

Reduction: get the Design Right; polish the solution. This may be done on the best solutions simultaneously.

The Design Funnel

                                          _______
                                   ------/
-----                   /---------/    Sales
---\ \___|--------------------\
    ---   Management/Marketing ----------\_______
       \_________________________________________
Design         ----------------------------------
       /------/                 |----------------
    --- /|              --------|
---/  -- | Engineering /
-----/   |----/-------/

Supporting Rapid Iterations

Fudd’s first law of creativity: to get a good idea, get lots of ideas.

Lots of ideas take lots of time to build/test, so we need rapid creation, evaluation and prototyping.

Prototyping

After user/task identification, prototyping can occur.

Low-fidelity paper prototypes (elaboration):

Medium-fidelity prototypes (reduction):

High-fidelity prototypes/restricted systems:

Working systems:

Low-Fidelity Prototypes: Sketches

Outward appearance and structure of intended design.

Necessarily crude and scruffy:

Use annotations/sequences to show UI progression.

Cross reference with other zoomed in/out sketches.

Sequential sketches: show state transitions; what interaction causes the state change?

Focus on the main transactions (Zipf’s law) - clearly convey how the user achieves the 20% of the most frequent interactions.

Medium-Fidelity Prototypes: Wizard of Oz

Have a person emulate the functionality.

IBM speech editor (1984): user would give audible commands to edit a text document, which the wizard implement. This gave IBM a good understanding of the user experience, allowing them to see if the idea was any good without investing a large amount of effort into actually implementing it.

Walk-through evaluation:

Refinement (e.g. PowerPoint):

Precise medium-fidelity prototypes:

Photo traces:

Simulations and animations:

Task-Centered System Design (TCSD)

TCSD is the HCI equivalent of requirements analysis/use cases.

It asks exactly and specifically who are the users and what will they use the system for? There is a critical difference between:

TCSD acts as a reality-based sanity check for designers.

Good book on system design: Task-Centered User Interface Design by Clayton Lewis and John Rieman.

How NOT to approach design:

UC SMS

UC’s student management system (from the mid 2000s) was a multi-million dollar, unusable disaster.

Example task: Andy is teaching COSC225 next semester; he wants to know how many students are enrolled to see how many printouts he needs. To achieve this:

The company that delivered it had a system that was similar to what UC needed; they did what was easy, not what the end user needed.

TCSD Phase 1: User Identification

Identify categories of end-users with specific exemplars - typical and extremes.

Talk to them!

TCSD Phase 2: Task Identification

  1. Record what the user wants to do, minimizing the description of how they do it
    • No interface assumptions; tasks are independent of the interface they will use to complete it
    • Can be used to compare alternative designs
    • Don’t write ‘display ${something} to the user’, write ‘do ${something}’: the user wants to get information about something; the system displaying it is just a way they can do it
  2. Record the complete task: input source, output identification
  3. Identify users
    • Design success depends on what users know
    • Test against specific individuals; name names
  4. Uniquely enumerate tasks for identification
    • Giving tasks a unique identifier helps with communicating problematic tasks with the team
  5. Identified tasks can be circulated for validations
    • Interview the users with the tasks you identified; they can help spot omissions, corrections, clarifications and unrealistic tasks
  6. Identify broad coverage of users and tasks
    • Create matrix with the axes of unimportant/important and infrequent/frequent tasks/users

Example: John Smith arrives at student services trying to enrol in a course online, but refused as he lacked a pre-requisite course. He has a letter from the HoD allowing him to enrol. He has forgotten his ID card and cannot remember his student ID or user code (<- this is an interface assumption; does the system have IDs or user codes?).

TCSD Phase 1/2 Outcomes

A report should state:

  1. User categories (and their priorities)
  2. Specific personas exemplifying each category
  3. Task categories and priorities
  4. Concrete representative task scenarios (with name of the owner)
    • Enumerated with unique identifiers for use in UI validation
  5. Explicit identification of groups/tasks that will not be supported and reasons for this

TCSD Phase 3: Design

Use task categories/scenarios to generate and evaluate designs.

Strive to make the workflow natural to the user. For each design and task scenario ask how the user would complete the task.

TCSD Phase 4: Walk-through Evaluation

Interface design debugging: select a task scenario and for each step:

Cautions on TCSD

User-Centred System Design

Know the user: design should be based around user needs, abilities, context, tasks etc. and should be involved in all stages of design: requirements, analysis, storyboards, prototypes etc.

UCSD/Participative Design: Involving the User

Talk to users:

UCSD: Participatory Design

Problem:

Solution:

The users:

However:

Erskine: member of Math/COSC departments became members of the design and judging team, gave suggestions to architects etc. (e.g. less glass - too much glare). When finished the staff had buy-in into the building; it was their building, not one built by management.

Usability Heuristics

AKA User-Interface Guidelines, Style Guides.

Usability heuristics:

Formative heuristics guide design decisions while summative heuristics evaluate existing systems.

Advantages:

Disadvantages:

Nielsen’s Ten

The original set defined Jakob Nielsen’s Usability Engineering:

01. Simple and Natural Dialogue

Manage complexity: make it as simple as possible, but no simpler (match the complexity of the domain).

Organization of the interface: make the presentation (appearance of each state) and navigation (between states) simple and natural.

Graphic design: organize, economize, communicate.

Use windows frugally - fewer windows are almost invariably better.

See: Google vs Yahoo search page, iPhone vs feature phones

02. Speak the User’s Language

Affordances, mappings and metaphors.

Terminology (words, colors, graphics, animations etc.) should be based on the user’s task language (and not based on system internals).

e.g. error messages should be useful to the user, not just the programmer/designer.

‘Language’ is textual and iconic (e.g. ‘Save’ (natural language) can be Ctrl-S , floppy disk icon).

03. Minimize The User’s Memory Load

Recall is slow and fragile; use recognition wherever possible:

04. Consistency

Consistency everywhere:

05. Feedback

Continually inform the user about what the system is doing and the system’s interpretation of their input.

e.g. in PS, cursor icon matches selected tool

The feedback should:

Response times:

Consider feedback persistence: how heavy/disruptive and enduring should it be?

06. Clearly Marked Exits

Avoid trapping the user; offer a way out whenever possible:

e.g. ‘Do you want to save the changes made to ${}’: Don’t Save, Cancel, Save (don’t just use ‘yes’/‘no’/‘cancel’)

Windows 10 volume control: area around the volume bar is untouchable for a few seconds Also placed in the top left corner where a lot of important user elements are.

07. Shortcuts

Enable high performance for experienced users:

08. Prevent Errors and Avoid Modes

People will make errors:

General rules:

Forcing functions (syntactic correctness):

Warnings:

Ignore illegal actions:

Mode errors:

Bad behavior:

Good example:

Possible solutions:

09. Deal with Errors in a Positive and Helpful Manner

Error messages should:

10. Help and Documentation

Documentation and manuals:

Tutorials:

Reminders:

Wizards:

Māori Issues and User Interface Design

Te Taka Keegan - University of Waikato

Usability principles

Shneiderman, Nielson have a few relevant usability principles:

Know your audience:

Something is usable if person of average ability and experience accomplish the task without more trouble than it’s worth.

Inspection Methods

Systematic inspection of a user interface. It:

Heuristic Evaluation

Each inspector initially works alone. They traverse the interface several times with a specific scenario/task in mind and:

It often uses a two pass approach, focusing on specific UI elements/states in the first pass while the second focuses on integration and flows between states.

Results Synthesis

After each inspector does their individual evaluation, the inspectors come together and assess the overlap in problems they found.

Severity rankings can be reviewed and compared, and problems ranked in order of importance.

Severity: (small impact on those encountering it, few users) = low severity. (large impact, many users) = high severity.

Inspectors

Different perspectives will catch different problems so the inspector team should be diverse.

Example:

All inspectors should be trained in Nielson’s heuristics.

Nielson claims 3 inspectors should be able to find ~60% of problems, 5 ~70%.

Graphical Screen Design

Gestlat Laws of Perceptual Organization

How humans detect visual groups/relationships/patterns:

Smooth continuity (e.g. smooth curves vs straight lines with right angles) easier to perceive, but less ‘neat’.

PARC Principles

From The Non-Designer’s Design Book by Robin Williams.

PARC:

Misc

Grids:

Navigational Cues:

Economy of visual elements:

03. User Interface Evaluation

Designers have complete and comprehensive knowledge of their interface and hence are uniquely unqualified to assess usability.

This makes them blind to the mismatch between the user and designer models. In order to find these, it is important to record realistic interactions; simple observation is insufficient.

Designers must mistrust their interfaces; what is difficult for a user may be obvious to them.

“Think Aloud” Evaluation

Prompt subjects to verbalize their thoughts as they work through the system:

It is hard to talk and concentrate on the task at the same time - you may get a lot of incomprehensible mumbling so the facilitator must ensure they give good and continual prompts to the user.

Apart from the prompts, it should be one-way communication from the subject - otherwise, you will pollute the user’s model.

It is also likely to be very uncomfortable, unpleasant and difficult for the subjects - do your best to make them comfortable.

Cooperative Evaluation

A variation of “think aloud”. In “think aloud”, it feels as if the user is being studied while with cooperative evaluation, two subjects study the system together (with natural two-way communication).

Sometimes, one of the subjects is a confederate - someone involved with the system.

The two subjects work together to solve the problem. It is more comfortable to the subjects and comments about failures of the system emerge much more naturally.

Interviews

The more obvious the technique appears, the less preparation designers intuitively think they need to put into it: designing good interviews (and questionnaires) is difficult and are expensive in terms of time for both the designers and users.

Interviews are:

Plan a central set of questions in for consistency between interviewees and to focus the interview, but still be willing to explore interesting leads.

Questionnaires

Expensive to prepare but cheap to administer - evaluator not required.

NB: ~20% response rate.

Questionnaires can give quantitative (e.g. 30% of users xyz) and qualitative (why did you like x). Question types:

Questionnaires are over-determined user interfaces - a badly-designed question may ‘box in’ the user. Hence, when designing questions:

Continuous Evaluation

Monitoring actual system use:

Crowd-Sourced Experiments

Mechanical turk et al.:

Formal Empirical Evaluation

When you want to see how a small number of competing solutions perform.

This requires strict, statistically testable hypotheses: better/worse or no evidence/difference.

Measure the participants’ response to manipulation of experimental conditions.

The results should be repeatable - the experimental methods must be defined rigorously, but are also time-consuming and expensive.

Ethics

Testing can be distressing.

As an experimenter you care about overall, not individual results, but if a subject makes a mistake, it can make them feel embarrassed and inadequate, especially if there are other other subjects that can see what they are doing.

Treat subjects with respect; at the very least, ensure the experience is not negative.

Before the test:

During the test:

Controlled Experiments

Characteristics:

Research Questions

Congratulations! You have invented ABC. Now you need a research question/hypothesis:

Most research questions are comparative:

Null Hypothesis Significance Testing (NHST):

μ^σ^/n \frac{\hat{\mu}}{\hat{\sigma}/\sqrt{n}}

Where:

We want to increase the signal-to-noise ratio, so we need to reduce the denominator:

Aside - the ‘file drawer’ effect:

Internal vs external validity:

Using multiple experiments, some with high internal validity and others with high external validity, can be used to overcome the shortcomings of both.

Be careful in generalizing conclusions:

Point analysis versus depth/theory/model:

Experimental Terminology

Independent variables:

Dependent variables:

Within vs. between subjects:

Counterbalancing:

                      Tiny
Population --------> Sample
                    + noise
  ^                     |
  | Inference           |
  | about the           |
  | population          |
  |                     |
   ---- Statistics <-----

Data Analysis

T-Test

Determines if two samples are likely to be from different populations?

Paired T-Test (within subjects): each participant is tested under both conditions.

Unpaired T-Test (between subjects): independent samples; each participant is only tested under one condition.

data <- read.table('filename', header=TRUE)

t.test(data$conditionA, data$conditionB, paired=TRUE|FALSE)
# If paired=TRUE, values on each row must belong to the same participant

# t-ratio: signal to noise. The bigger (the absolute value), the better
# p-value: can reject null hypothesis if p is less than $\alpha = 0.05$

Lots of additional information available through pairing, dramatically increasing sensitivity: t-ratio will usually be much larger and p-value smaller.

Correlation: Relating Datasets

Determining the strength of the relationship between variables (e.g. is typing and pointing speed correlated?).

Many different models available (e.g. linear, power, exponential), but always look at the graph to see if the model fits.

Common models:

Remember that correlation does not mean causation.

Regression: Relating Datasets

Predicting one value from another.

Line of best fit:

Analysis of Variance (ANOVA)

T-tests allow us to compare between two samples with different values for an independent variable. But what about if the independent variable (factor) can take on more than two values?

We could simply exhaustively compare all pairs, but if the IV can take on nn values, there will be n(n−1)2\frac{n(n - 1)}{2} comparisons. Each comparison may find a statistically significant difference by chance (Type I error), so as nn increases, the chance of falsely finding at least one statistically significant difference between pairs increases quadratically.

ANOVA supports factors with more than two levels of a factor and handle multiple factors, while reducing the risk of incorrectly rejecting the null hypothesis by asking if all conditions are from the same population: H0:μ1=μ2=⋯=μnH_0: \mu_1 = \mu_2 = \dots = \mu_n. Invert this to see if at least one condition is different.

If there is only one factor (independent variable), it is called one way ANOVA. Factors can be either within or between subjects (although you cannot do both within a factor).

COSC368 Exam Notes

Pillars of usability:

HCI should aim for simplicity; aim to make the UI match the complexity of the domain.

Don Norman’s Model of Interaction:

               constructs
   Designer/ -------------> System/system image
designer model                ^
                    Provides  | Provides input based on
                    feedback/ | their prediction of how
                     output   |  to achieve their goal 
                              v
                             User/
                          user model

Designer model:

User model:

System Image:

Execute-Evaluate Cycle:

UISO:

Mappings:

Humans Input:

Human output:

Fitt’s Law

Steering Law:

Hick/Hyman Law of Decision Time:

Power Law of Practice:

Novice to Expert:

Human Memory:

Slips:

Human phenomena:

Top-level design process:

Iterative design: don’t find a single idea and improve on that: leads to premature commitment, local maxima, and tunnel vision

Elaborative/reduction: first explore the full design space, then refine the design(s)

Task-Centered System Design (TCSD):

User-Centered System Design (UCSD):

Nielson’s Ten Heuristics:

  1. Simple and natural dialogue
    • Make it as simple as possible but no simpler
    • Presentation + navigation should be natural and consistent
    • Design: organize, economize, communicate
  2. Speak the user’s language
    • Affordances (it is used the way it looks like it should be used)
    • Mappings
    • Metaphors
    • Base terminology on user’s task language, not implementation
  3. Minimize memory load
    • Recall slow; use recognition where possible
    • Show input formats, provide defaults (e.g. date fields - what format is it supposed to be entered in, can a sensible default be provided?)
    • Support reuse/re-visitation (e.g. show a few of the most commonly or recently used)
    • Support unit exchange
    • Support generalization: universal commands, modifiers
  4. Consistency
    • In graphic design
    • In command structure (e.g. pick command then select object or select object and run command)
    • Internally
    • Externally (within the platform)
    • Beyond computing
  5. Feedback
    • Continuous feedback about the system state and system’s interpretation of user input
    • Feedback should be:
      • Specific
      • Consider feed-forward: show effect of action before it is committed
    • Autocomplete
      • Must be stable and predictable - muscle memory, not reading
      • Consider persistance: how disruptive and enduring should the feedback be?
  6. Clearly-marked exits; don’t trap the user
    • Cancel buttons, universal undo, interrupt long-running operations etc.
    • More recent actions should override older ones
    • Quit
      • ‘Do you want to save changes to ${filename}?’: ‘Don’t Save’, ‘Cancel’, ‘Save’; should be specific
  7. Shortcuts
    • Keyboard accelerators
    • Command completion, type-ahead
    • Function keys
    • Double clicking
    • Gestures
    • History
    • Customizable toolbars
  8. Prevent errors, avoid modes
    • Syntactic correctness - disable items that aren’t valid
    • Feedback reduces chance of slips
    • Easy correction - universal undo
    • Commensurate effort: states difficult to get to should be difficult to irreversibly leave
    • Forcing functions: prevent behavior until problem corrected
      • Interlocks: force right order of operations (e.g. remove card before ATM dispenses cash)
      • Lock-ins: force user to remain in space (e.g. would you like to save changes dialog on close)
      • Lock-outs: force user leaving space or prevent event from occurring
      • Don’t just ignore illegal actions - user must infer what is wrong
    • Mode errors:
      • Have as few modes as possible
      • Make current mode easily apparent
      • Spring-loaded modes: ongoing action required to stay in mode
  9. Deal with errors positively and helpfully
    • Clear language, not codes
    • Precise
    • Constructive - offer solutions
  10. Help and documentation
    • Documentation is not permission to design a crappy UI
    • Write the manual before the system
    • Reminders: tooltips
    • Wizards: puts system, not user in control. Don’t overuse
    • Tutorials

Heuristic evaluation:

Gestalt Laws of Perceptual Organization:

PARC Principles:

Misc:

UI Evaluation:

TODO: 03. User Interface Evaluation.