Pursuit: Programming in the User Interface
		Francesmary Modugno


My thesis explores the design of PURSUIT, a visual shell that enables
users to access the common functionality of Unix without learning
concepts beyond those of the Macintosh.  A visual shell, (e.g., Apple
Macintosh Finder), is a direct manipulation interface to an operating
system.  Many visual shells lack the power and functionality of Unix
shells that users most often desire.  For example, they are not
programmable; they do not allow users to ``pipe'' the output of one
command into another; and they lack the common functionality of
powerful utilities such as {\tt awk, sed, merge, find, sort}, etc.
Previous visual shells that do provide this power are difficult to
use.  This research focuses on developing a direct manipulation
interface that provides these functionalities in a way that is
consistent with the direct manipulation paradigm, without requiring
users to learn obscure programming languages, commands or interaction
techniques.



To enable users to construct programs, PURSUIT contains a programming
by example (PBE) system.  In a PBE system, users execute actions on
data and the underlying system attempts to construct a program.  Such
systems have limitations: feedback is often difficult to understand,
disruptive or non existent; and programs often have no representation
for users to examine or edit.




PURSUIT addresses these problems by presenting the inferred program in
a novel editable {\it graphical} language {\it while it is being
constructed}.  In the language, icons represent data and changes to
data icons represent operations.  The representations are similar to
the objects and effects that users see in the real interface.  This
provides users with an immediate, editable view of the code and
feedback that is familiar, easy to understand, and non-disruptive.


In order to allow users to construct ``pipes'' and access some of the
common functionality of utilities, PURSUIT utilities output typed
icons, rather than untyped text like other visual shells.  By
selecting the output of one utility and using it as input to another
utility, users can create straight-line programs (i.e., Unix pipes)
directly in the interface.  By manipulating the output of utilities
using standard selection and editing commands, users can access some
of the common functionality of utilities, such as column selection in
{\tt awk}, without knowing any special utility names and flags.  For
example, the Unix sequence {\tt rm `grep hello * | awk -F: `\{print
\$1\}' | sort -u'} removes all those files containing the string
``hello'' from the current directory.  To do this in PURSUIT, users
execute the {\tt search} utility with the string ``hello''.  The {\tt
search} utility outputs file objects referencing the actual files
containing the search string.  Users then drag the output files to the
trash - the same sequence used to remove the actual files from a
folder.


Using informal user testing with paper mock-ups, the visual language
design has been completed.  An extension language was also designed so
that the visual language can include representations of utilities
added to the system at a later time.  A prototype of PURSUIT
containing typed utility output has already been implemented and the
visual language is now being added.  Further user testing will help
refine the language and interface designs.