CS789, Spring 2007

Lecture notes, Week 1

History of User Interfaces

But first we need to defines some terms.

UI, UIMS

Individual applications have user interfaces (UIs). A user interface can be instantiated or managed by a user interface management system (UIMS). Making these can be considered an engineering discipline: designing useful artifacts.

HCI, CHI

A UI should fit its users well. To make this happen the design process requires knowledge about how computers and humans interact interact, which is created by a scientific process that investigates humans & computers as they interact, seeking universal laws that describe the interaction

0. The Computer

The computer executes a sequence of instructions, manipulating its internal state, consuming input and producing output.

Branch one: the engineering branch

• The computer substitutes (or augments) invisibly.
• Input and output devices ramify without limit
  • e.g. the humble dishwasher
  • recursive ramification
• The computer itself is a black box
  • possibly multiple programs selectable by input or by state/history
• Programmability is (almost) exhausted at the time of manufacture
• This is ubiquitous computing: everything old is new again!

Branch two: the computer as programmable object

Single programmers are able to create these superb artifacts out of the most malleable substance yet discovered.

N. B. The branches will be seen to be rejoining one another toward the end of computer evolution.

1. Writing Programs - 1950-1970

The Compiler

The compiler is used to assemble program fragments into a program.

Using it effectively requires

• random access into the program components
• support for abstraction
• libraries of reusable program components
• (purely technical) translation of programs into runnable objects

In providing this we have the following problems to solve

• program representation(s) having the following properties
  • human readable
  • dividable into parts and parts of parts
  • substitution at the level of parts or parts of parts
  • must support random access for human perception
  • must support random access for human manipulation
• access to pre-defined components

They are solved by the following interface innovations

• the card deck
• the listing
• the procedure library
• the manual

2. Running Programs - 1970-1990

Operating systems provide the ability to manage on-line, multiple (independent) computations (multi-programming).

Using them effectively requires

• real-time access to job control
• on-line user/program interaction
• on-line program/program interaction

In doing this we have the following problems to solve

• proper direction (synchronization) of input and output
• how to manage program environment (context, state)
  • technical environment
  • cognitive environment
• arranging data sharing, communication

They are solved by the following interface innovations

• glass teletype, shell programming
  • supports conversational interfaces
  • user/program dialogue
• inter-working
  • the file system

N. B. Changes associated with the invention of operating systems influence how the compiler is used. (E.g., the teletype makes possible the screen editor.) The recursive nature of computation means that examining a program (the listing) or changing it (the card-deck) can now be done by running a program under the supervision of the operating system. What's important here is that interface innovation is cumulative.

3. Interacting with Programs - 1990-present

These are tools for manipulating documents that are semi-structured. The program determines part of the structure; the user determines the rest. The first part of the structure is global (to the program); the second part is local (to the document).

• manipulative access to semi-structured data
  • access must be random
• autonomous activities
  • spreadsheet updating, wordprocessor formatting

Using them effectively requires

• random access into local data
  • cognitive access (where is it?)
• efficient input
  • copying, rearranging
• visible presentation of document state

In doing this we have the following problems to solve

• visible state presentation, random access
  • synchronization state of autonomous activities
• interworking
• high input and output rates
  • doing the same thing many times (context-sensitive)

They are solved by the following interface innovations

• bit-mapped display, pointing device (V. Gui)
• the clipboard
• keystroke equivalents
• style sheets

4. What Next?

These are applications, like web-browsing, that require wide-area access to semi-structured data. This data is very similar to the information stored in the human brain; to use it effectively it is necessary to compete successfully against human memory.

Using them effectively requires

• high speed scale-independent interfaces
• navigation tools
• data assembly mechanisms

In doing this we have the following problems to solve

• consistency (event horizon)
• interworking (removing/standardizing context)

The interface innovations we expect to support this are

• associative models of data access
• high speed cut-and-paste

Learning

Constraints on learning

1930s to 1950s: Watson & Skinner

1990s to present: neuroscience aka wetware

What kinds of things do users know?

They know

1. facts, "Ottawa is the capital of Canada", knowing that
2. procedures, putting a spoon into your mouth without hitting your lips, knowing how

"Knowing how" can be divided into four different categories

1. Operational, perceptual/motor capabilities: how to move fingers and aim them at keys
2. Rule-based, motor programs triggered by categorical perception: to end input hit ESC (to start command hit ESC)
3. Cognitive procedures, sequences of rules that solve stereotyped problems: to look at every ifdef in vi, type /ifdef, look at what you got, then type / repeatedly, watching for reappearance of the first occurrence.
4. Problem analysis and solution, creation of new cognitive procedures: to find the bug check all the ifdefs

Here's another way of clssifying things that users know

1. Recognition: Which of "Exit" or "Quit" exits from WordPerfect
2. Recall: "lc" gives the contents of the current directory at Waterloo

Ways of changing knowledge = "learning"

1. Trial-and-error: putting on a nut, riding a bicycle
2. Practice = rehearsel: using a hammer
3. How-to-do it descriptions: cookbook recipes
4. Modification of examples: making html pages

And an orthogonal classification

1. Search, result-motivated: goals, how to set the time on the clock radio in a car
2. Browsing, exploration: curiosity, bi-product, where does that tunnel go?

And another orthogonal classification

1. Manuals, help pages: recipes, principles, examples.
2. Experimentation: empirical information, observations.
3. Other users: solutions, analogies, models.

Note. Testing the solution is a normal termination step in many learning processes. How many times should a solution be tested? What determines how many times a particular piece of learning should be tested?

Return to:

• Bill Cowan's home page.
• Bill Cowan's teaching page.
• Bill Cowan's CS789 page.
• Bill Cowan's CS789 page for Spring 2007.