Interface
`Pad++: A Zooming Graphical
`for Exploring Alternate Interface Physics
`
`Benjamin B. Bederson*
`Bell Communications Research
`445 South Street - MRE 2D-336
`Morristown, NJ 07960
`(bederson@bellcore.tom)
`
`James D. Hollun
`Computer Science Department
`Universi~
`of New Mexico
`Albuquerque, NM8713 1
`(hollan@cs.unm.edu)
`
`KEYWORDS
`Interactive
`interfaces,
`information
`
`interfaces,
`user interfaces, multiscale
`authoring,
`information
`navigation,
`visualization,
`information
`physics.
`
`zooming
`hypertext,
`
`ABSTRACT
`We describe the current status of Pad++, a zooming graphical
`interface that we are exploring as an alternative to tradhional
`window and icon-based approaches to interface design. We
`discuss the motivation
`for Pad++, describe the implementa-
`tion, and present prototype applications.
`In addition, we intro-
`duce an informational
`physics strategy for
`interface design
`and briefly compare it with metaphor-based design strategies.
`
`INTRODUCTION
`icons,
`If
`interface designers are to move beyond windows,
`menus, and pointers to explore a larger space of interface pos-
`sibilities,
`new interaction
`techniques must go beyond the
`desktop metaphor, While several groups are exploring virtual
`3D worlds [4][8], we have developed a 2D interface based on
`zooming. With our system, Pad++, graphical data objects of
`any size can be created, and zooming is a fundamental
`inter-
`action technique.
`
`approaches,
`There are numerous benefits to metaphor-based
`but they also lead designers to employ computation primarily
`to mimic mechanisms of older mdla, While there are impor-
`tant cognitive,
`cultural,
`and engineering
`reasons to exploit
`earlier
`successful
`representations,
`this approach
`has the
`potential of underutilizing
`the mechanisms of new media,
`
`a different
`few years we have been exploring
`the last
`For
`strategy for interface design to help focus on novel mecha-
`nisms enabled by computation
`rather
`than on mimicking
`mechanisms of older media.
`Informally
`the strategy consists
`
`Permission to copy without fee all or part of this material is granted
`provided that the copies are not made or distributed for direct com-
`mercial advantage, the ACM copyright notice and the title of the pub-
`lication and its date appear, and notice is given that copying is by
`permission of the Association for Computing Machinery, To copy
`otherwise, or to republish, requires a fee and/or specific permission.
`
`@ 1994 ACM 0-89791 -857-3/94/001 1....$3.50
`
`of viewing interface design as the development
`of appearance and behavior
`for collections
`of
`objects.
`
`of a physics
`informational
`
`physics might
`informational
`an effective
`For example,
`arrange for useful
`representations
`to be a natural product of
`normal activity. Consider how this is at times the case for the
`physics of
`the world. Some materials record their use and in
`doing so influence future use in positive ways. Used books
`crack open at often referenced places. Frequently
`consulted
`papers are at the top of piles on our desks. Use dog-ears the
`comers and stains the surface of index cards and catalogs. All
`these provide representational
`cues as a natural product of
`interaction
`but
`the physics of older media limit what can be
`recorded and the ways it can influence future use.
`
`physics strategy has lead us to
`an informational
`Following
`explore history-enriched
`digital objects [11] [12]. Recording
`on objects (e.g. reports,
`forms, source-code, manual pages,
`email, spreadsheets) the interaction events that comprise their
`use makes it possible on future occasions, when the objects
`are used again,
`to display
`graphical
`abstractions
`of
`the
`accrued histories
`as parts of
`the objects
`themselves.
`For
`example, we depict on source code its copy history so that a
`developer can see that a particular
`section of code has been
`copied and perhaps be led to correct a bug not only in the
`piece of code behg viewed but also in the code from which it
`was derived.
`
`physics strategy has also lead us to explore
`This informational
`new physics for interacting with graphical data. In collabora-
`tion with Ken Perlin, we have designed a successor
`to Pad
`[17] which is an graphical
`interface based on zooming. This
`system, Pad++, will be the basis for exploration
`of novel
`interfaces
`for
`information
`visualization
`and browsing
`in a
`number of complex information-intensive
`domains. The sys-
`tem is being designed to operate on platforms
`ranging from
`
`*This author has moved to the University of New Mexico, Comput-
`er science Department,
`Albuquerque,
`NM 87131, bcder-
`son@cs.unm.edu.
`
`November 2-4, 1994
`
`UIST ’94
`
`17
`
`Petitioner Exhibit 1016, Page 1
`
`

`

`to PDAs and Set-top boxes.
`high-end graphics workstations
`behind the Pad++ develop-
`Here we describe the motivation
`ment,
`report
`the status of
`the current
`implementation,
`and
`present some prototype applications.
`
`MOTIVATION
`It is a truism of modem life that there is much more informat-
`ion available than we can readily and effectively
`access. The
`situation is further complicated
`by the fact
`that we are on the
`threshold of a vast increase in the availability
`of
`information
`because of new network and computational
`technologies.
`It is
`somewhat paradoxical
`that while we continuously
`process
`massive amounts of perceptual
`data as we experience
`the
`world, we have perceptual access to very little of the informa-
`tion that
`resides within
`our computing
`systems or that
`is
`reachable via network connections.
`In addhion,
`this informa-
`tion, unlike the world around us, is rarely presented in ways
`that reflect either its rich stxucture or dynamic character.
`
`infor-
`We envision a much richer world of dynamic persistent
`mational entities that operate according to multiple
`physics
`specifically designed to provide cognitively
`facile access. The
`physics need to be designed to exploit semantic relationships
`explicit and implicit
`in information-intensive
`tasks and in our
`interaction with these new kinds of computationally
`-based
`work materials.
`
`at
`to Pad++ supports viewing information
`One physics central
`different
`scales and attempts to tap into our natural spatial
`ways of
`thinking.
`The information
`presentation
`problem
`addressed is how to provide effective access to a large body of
`information
`on a,much smaller display. Fumas [9] explored
`degree of interest
`fi.mctions to determine the information
`visi-
`ble at various distances from a central
`focal area. There is
`much to recommend the general approach of providing
`a cen-
`tral
`focus area of detail surrounded by a periphery that places
`tie detail
`in a larger context.
`
`With Pad++ we have moved beyond the simple binary choice
`of presenting or eliding particular
`information. We can also
`determine
`the scale of
`the information
`and, perhaps most
`importantly,
`the details of how it is rendered can be based on
`various semantic and task considerations
`that we describe
`below. This provides semantic task-based filtering of informat-
`ion that is similar
`to the early work at MCC on HITS[13]
`and
`the recent work of moveable filters at Xerox [3][18].
`
`The ability to make it easier and more intuitive to find specific
`information
`in large dataspaces is one of the central motiva-
`tions for Pad++. The traditional
`approach is to filter or recom-
`mend a subset of
`the data, hopefully
`producing
`a small
`enough dataset for the user to effectively
`navigate. Two recent
`examples of work of
`this nature are latent semantic indexing
`[5] and a video recommender
`service based on shared ratings
`with other viewers [10].
`
`approaches in that
`to these filtering
`Pad++ is complementary
`it
`is a useful substrate to structure
`information.
`In concert
`with recommending mechanisms, Pad++ could be used to
`layout
`the rated information
`in a way to make the most highly
`
`rated information
`related but lower
`
`largest and most obvious, while placing
`rated information
`nearby and smaller.
`
`DESCRIPTION
`visualiza-
`substrate for exploring
`Pad++ is a general-purpose
`tions of graphical data with a zooming interface. While Pad++
`is not an application
`itself,
`it directly
`supports creation and
`manipulation
`of multiscale
`graphical objects, and navigation
`through the object space.
`It
`is implemented
`as a widget
`for
`Tcl/Tk
`[16]
`(described
`in a later section) which provides
`a
`simple mechanism for creating zooming-based
`applications
`with an interpreted language. The standard objects that Pad++
`supports are colored text,
`text
`files, hypertext, graphics, and
`images.
`
`using Pad++
`application
`We have written a simple drawing
`that supports interactive drawing and manipulation
`of objects
`as well
`loading of predefine
`or programmatically
`created
`objects. This application
`produced all
`the figures depicted in
`this paper.
`
`The basic user interface for Pad++ uses a three button mouse.
`The left button is mode dependent. For the drawing applica-
`tion shown in this paper, the left button might select and move
`objects, draw graphical objects, specify where to enter text,
`etc. The middle button zooms in and the right button zooms
`out. Pad++ always zooms around the current cursor position -
`thus the user can control
`the zooming dynamically
`by moving
`the mouse while zooming.
`For systems with a two button
`mouse, we have experimented with various mechanisms
`for
`mapping zooming in and out to a single button. Typically,
`this
`involves having the first motion of the mouse after the button
`press determine the direction of the zooming.
`
`of
`abstraction
`representing
`Pad++ is a natural substrate for
`to
`It
`is natural
`objects using what we term semuntic zooming.
`see the details of an object when zoomed in and viewing it up
`close. When zoomed out, however,
`instead of simply seeing a
`scaled down version of the object,
`it is potentially more effec-
`tive to see a different
`representation
`of
`it. Perlin
`[17]
`described a prototype zooming calendar with this notion, We
`foresee two ways to describe this type of object. The first
`is to
`have different
`objects, each of which is visible at different,
`non-overlapping,
`zooms. This method is supported with the -
`minsize and -maxsize options described in the TcVI’k Section.
`The second, and prefemed method,
`is to describe a procedural
`object
`that renders itself differently
`depending on its viewing
`size or other characteristics.
`It is possible to prototype proce-
`dural objects with Tcl as described below,
`
`RECENT ADVANCES
`has been to provide
`implementation
`Our focus in the current
`smooth zooming in a system that works with very large graph-
`ical datasets. The nature of
`the Pad++ interface requires con-
`sistent high frame-rate
`interactions,
`even as the dataspace
`becomes large and the scene gets complicated.
`In many appli-
`cations, speed is irrtportan~ but not critical
`to functionality.
`In
`Pad++, however,
`the interface paradigm is inherently
`based
`on interaction.
`The searching strategy is to visually explore
`
`18
`
`UIST ’94
`
`Marina del Rey, California
`
`Petitioner Exhibit 1016, Page 2
`
`

`

`Figure 1: Sequence of snapshots (from left to right and top to bottom) as the view is
`zoomed in to a hand-drawn picture.
`
`the dataspace, so it is essential
`maintained,
`
`that
`
`interactive thrne rates be
`
`IMPLEMENTATION
`two
`It runs on either of
`Pad++ in C++.
`We implemented
`the Silicon Graphics computers graphics
`graphics systems:
`(GL); and standard X. The X version runs
`language facilities
`on SGI’S, Suns, PC’s running Llnux, and should be trivially
`portable to other standard UnixR system. Pad++ is imple-
`mented as a widget
`for Tcl/Tk which allows applications to be
`written in the interpreted Tcl
`language. All Pad++ features are
`accessible through Tcl making it unnecessary
`to write any
`new C code.
`
`EFFICIENCY
`In order to keep the animation frame-rate up as the dataspace
`
`several stan-
`increases, we implemented
`size and complexity
`dard efficiency methods, which taken together create a power-
`ful system. We have successfully loaded over 600,000 objects
`and maintained interactive rates.
`
`Briefly,
`
`the implemented efficiency methods include:
`
`l
`
`l
`
`l
`
`l
`
`e
`
`Indexing: Create a hierarchy of objects based on
`Spatial
`bounding boxes to quickly index to visible objects.
`
`restructure the hierarchy
`Automatically
`Restructuring:
`of objects to maintain a balanced tree which is necessary
`for the fastest indexing.
`
`Render only the detail needed,
`Spatial Level-Of-Detail:
`do not render what can not be seen.
`
`Clipping: Only render the portions of objects that are
`actually visible.
`
`Refinement: Render fast with low resolution while navi-
`
`November 2-4, 1994
`
`UIST ’94
`
`19
`
`Petitioner Exhibit 1016, Page 3
`
`

`

`gating and refine the image when still.
`
`Keep the zooming rate
`l Adaptive Render Scheduling
`constant even as the frame rate changes.
`
`through any large dataspace is
`One challenge in navigating
`maintaining
`a sense of relationship
`between what you are
`looking at and where it
`is with respect
`to the rest of
`the data
`(i.e., balancing
`local detail and global context). The rough
`animation or jumpy
`zooming as implemented
`in the original
`Pad [17] can be disorienting
`and thus not provide the most
`effective support
`for the cognitive and perceptual processing
`required for interactive information
`visualization
`and naviga-
`tion.
`
`issue when accessing
`interface
`interactive
`An important
`external
`information
`sources is how to give the user access to
`them without
`incurring
`substantial
`start-up costs while the
`database is parsed and loaded.
`In Pad++ this is accomplished
`with parallel
`lazy loading: only load the portion of
`the data-
`base that
`is visible in the current view. As the user navigates
`through the database and looks at new areas, those portions of
`the database are loaded. This lazy loading is accomplished in
`the background
`so the user can continue
`to interact with
`Pad++. When the loading is complete,
`items appear
`in the
`appropriate place.
`
`is that of ephemeral objeets. Objects in
`An associated concept
`Pad++ which
`are representations
`of data on disk can be
`labeled ephemeral. These objects are automatically
`deleted if
`they have not been viewed in several minutes,
`thus freeing
`system resources. When they are viewed
`again,
`they are
`loaded again in parallel as described above.
`
`HYPERTEXT
`there is no graphical
`systems,
`window-based
`In traditional
`among windows
`even when
`the relationship
`depiction
`of
`there is a strong semantic relationship. This problem typically
`comes up with hypertext.
`In many hypertext systems, clicking
`on a hyperlink
`brings up a new window (or alternatively
`replaces the contents of
`the existing window). While there is
`an important
`relationship
`between these windows @rent and
`child),
`this relationship
`is not represented.
`
`layouts of
`with multiscale
`We have begun experimenting
`represent
`the parent-child
`hypertext where we graphically
`relationships between links. When a hyperlink
`is selected,
`the
`linked data is loaded to the side and made smaller, and the
`view is animated to center the new data.
`
`in Pad++ is quite
`The user interface for accessing hypertext
`simple. The normal navigation
`techniques are available, and
`in addition,
`clicking
`on a hyperlink
`loads in the associated
`data as described above, and shift-clicking
`anywhere on a
`hypertext object animates the view back to that object’s par-
`ent.
`
`in the Hypertext
`files written
`Pad++ can read in hypertext
`the language used to describe
`Markup
`Language (HTML),
`objects in the well-known
`hypertext system, MOSAIC (from
`
`Illinois). While we do not yet
`of
`the NCSA at the University
`follow links across the network, we can effectively
`use Pad++
`as an alternative
`viewer
`to MOSAIC within our file system.
`Figure 2 shows a snapshot with one of
`the author’s home-
`page loaded and several
`links followed.
`
`INTERFACE TO TCIJTK
`for Tk which provides for sim-
`Pad++ is built as a new widget
`ple access to all of
`its features through Tel, an interpreted
`scripting language. Tcl and Tk [16] are an increasingly popu-
`lar combination
`of scripting language and Motif-like
`library
`for creating ~aphical
`user interfaces and applications without
`writing any C code. The Tel
`interface to Pad++ is designed to
`be very similar
`to the interface
`to the Tk Canvas widget
`-
`which provides a surface for drawing structured graphics.
`
`in the Tk Can-
`everything
`implement
`While Pad++ does not
`vas yet, it adds many extra features - notably those supporting
`multiscale
`objects and zooming.
`In addition,
`it supports
`images,
`text files, and hypertext, as well as several navigation
`tools including
`content-based
`search. As with the Canvas,
`Pad++ supports many different
`types of structured graphics,
`and new graphical widgets can be added by writing C code.
`Significantly,
`all
`interactions
`with Pad++ are available
`through Tel.
`
`is interpreted and thus slower than compiled code, it
`Since Tcl
`is important
`to understand what
`its role is in a real-time ani-
`mation
`system such as Pad++. There are three classes of
`things that one can do with Pad++, and the importance
`of
`speed varies:
`
`l Create objects: Slow -
`
`Tel
`
`is fine
`
`l Handle events: Medium - Small amount of Tel
`
`is ok
`
`@Render scene: Fast -
`
`C++ only
`
`only a
`is done in C++, and typically
`Because all rendering
`few lines of Tcl are written to handle each event, Pad++ main-
`tains interactive rates despite its link to Tel. Tel
`is quite good,
`however,
`for reading and parsing input
`files, and creating and
`laying out graphical multiscale objects.
`
`interfaee to Pad++ is, as previously mentioned, quite
`The Tel
`to that of
`the Tk canvas, and is summarized
`here to
`similar
`give a feel
`for what
`it is like to program Pad++. Every object
`is assigned a unique integer
`id, In addition,
`the user may asso-
`ciate an arbitrary list of text tags with each object, Every com-
`mand can be directed to either a specific objeet
`id or to a tag,
`in which case it will apply to all objects that share that
`tag -
`implicitly
`grouping objects. Each Pad++ widget has its own
`name. All Pad++ commands start with the name of
`the wid-
`ge~ and in the examples that follow,
`the name of the widget
`is
`. pad.
`
`Examples:
`
`l A red rectangle with a black outline is created whose cor-
`ners are at the points (O, O) and (2, 1):
`pad
`create
`rectangle
`O 0 2 1 -f
`-outline
`black
`
`red
`
`ill
`
`e Putitem number 5 at the Iccation (3, 3), make the object
`
`20
`
`UIST ’94
`
`Marina del Rey, California
`
`Petitioner Exhibit 1016, Page 4
`
`

`

`Figure 2: Hypertext. Links are followed and placed on the surface to the side, and made smaller.
`
`November 2-4, 1994
`
`UIST ’94
`
`21
`
`Petitioner Exhibit 1016, Page 5
`
`

`

`milliseconds
`pad
`center
`
`for the animation:
`37
`500
`
`l Return the list of object
`.pad find
`withtext
`
`ids that contain the text “foo”
`f oo
`
`based on these commands.
`Figure 3 shows a Tk interface
`Entering text
`in the top entry region returns a list of objects
`that contain that text. Double clicking on any of these objects
`smoothly animates the view to the specified object.
`
`in pan and zoom to bring
`interpolate
`The smooth animations
`If the end point, however,
`is
`the view to the specified location.
`more than one screen width away from the starting point,
`the
`animation zooms out
`to a point midway between the starting
`and ending points,
`far enough out so that both points are visi-
`ble. The animation then smoothly zooms into the destination,
`This gives a sense of context
`to the viewer as well as speeding
`up the animation
`since most of
`the panning
`is performed
`when zoomed out which covers much more ground than pan-
`ning while zoomed in.
`
`Figure 3: Content based search
`
`VISUALIZATIONS
`to explore how smooth
`browser
`We built a Pad++ directory
`zooming and the various efficiency mechanisms help in view-
`ing a large hierarchical
`database, and to experiment
`with
`multi-scale
`layouts. The Pad++ directory browser provides a
`graphical
`interface for accessing the directory
`structure of a
`filesystem (see Figure 4). Each directory
`is represented by a
`square frame, and files are represented by solid squares col-
`ored by file type. Both directories and files show their
`filena-
`mes as labels when the user is sufficiently
`close to be able to
`read them, Each directory has all of its subdirectories and files
`organized
`alphabetically
`inside
`of
`it. Searching
`through
`the
`directory
`structure can be done by zooming in and out of the
`directory
`tree, or by using the content based search mecha-
`nisms described
`above. Zooming
`into a file automatically
`loads the text
`inside the colored square and it can then be
`edited and annotated.
`
`tree with over 600,000
`We are able to load in a directory
`objects, and maintain interactive animation rates of about 10
`frames per second. Spatial
`indexing allows us to explore very
`
`twice as big, and make the object anchored at that point
`on its northwest cornec
`pad
`itemconfig
`5 -anchor
`
`“3
`
`3 2“
`
`nw -place
`
`c Specify that item number 5should only be visible when
`its largest dimension is greater than 20 pixels and less
`than 100 pixels.
`pad
`itemconfig
`
`20
`
`-maxsize
`
`100
`
`5 -minsize
`
`lMakeallitems
`theleftbutton
`turnbluewhen
`withtagfoo
`of the mouse is pressed over any of those objects:
`pad
`bind
`foo
`<ButtonPress>
`{pad
`itemconfig
`foo
`
`blue)
`
`-fill
`
`environmentto
`anatural
`Pad++is
`As mentionedpreviously,
`represent abstraction through semantic zooming. Objects can
`be represented differently
`depending on their size by defining
`procedural
`objects. A procedural
`object
`is one that
`is ren-
`dered as a result of a special procedure (as opposed to pre-
`define
`static objects such as lines or text). Pad++ supports
`Tcl procedural objects which are very useful
`for prototyping,
`but
`too slow for continued use. Tcl procedural
`objects work
`by specifying
`two Tcl scripts. One returns the bounding box
`of the object
`(necessary for efficiency),
`and the other renders
`the object
`(drawing routines are provided). A trivial example
`is shown here which draws “1993”
`in red when it
`is small,
`and “Jan Feb Mar”
`in black when it is a little biggen
`
`makecalendar
`pad
`create
`
`{
`{ }
`-script
`
`tcl
`
`“cal”
`
`-bb
`
`“calBB”
`
`cal
`
`set
`set
`if
`
`{ }
`view
`size
`($size
`pad
`pad
`pad
`} else
`pad
`pad
`pad
`
`{
`
`move_to]
`$view
`
`2]
`
`{
`[ pad
`[lindex
`< .1}
`set_color
`set_linewidth
`draw_text
`
`set_color
`set_linewidth
`draw_text
`
`{
`
`red
`
`2
`“ 1993”
`
`black
`
`1
`
`0 0
`
`“Jan
`
`Feb Mar”
`
`O 0
`
`)
`
`calBB
`return
`
`{
`{}
`“O O 11
`
`1“
`
`proc
`
`} p
`
`roc
`
`) p
`
`roc
`
`} N
`
`AVIGATION
`very
`surface is obviously
`on thePad++
`Finding information
`through largedataspaces
`is
`navigation
`important
`as intuitive
`one ofits primary motivations. Pad++ support visual search-
`ing with zooming in addhiont otraditional
`mechanisms, such
`ascontent-based
`search.
`
`arepro-
`and searching mechanisms
`Some basic navigation
`videdattheTcl
`interface forthe
`application
`programmer. A
`fewbasiconesare:
`
`l Smoothly gotothe
`1000 milliseconds
`pad
`move_to
`
`location (l,O)at
`for the animation:
`1 0 5 1000
`
`zoomof5,
`
`and take
`
`l Smoothly go to the location such that object #37 is cen-
`tered, and fills three quarter’s of the screen, and take 500
`
`22
`
`UIST ’94
`
`Marina del Rey, California
`
`Petitioner Exhibit 1016, Page 6
`
`

`

`
`
`Figure 4: Directory browser snapshot
`
`
`
`1994
`November 24,
`November 2-4, 1994
`
`UIST ’94
`UIST “94
`
`23
`23
`
`Petitioner Exhibit 1016, Page 7
`
`Petitioner Exhibit 1016, Page 7
`
`

`

`large databases while keeping the search time fast, since we
`render only the visible portion of the scene. While navigating
`with Pad++, very small objects are not drawn and larger ones
`are drawn with reduced resolution.
`The objects
`are then
`refined and drawn at high resolution
`when the user stops
`changing the view.
`
`of
`dataset we looked at with Pad++ is a timeline
`Another
`interesting products, events, and papers in computer
`tecbnol-
`ogy and user interfaces. History naturally lends itself
`to behg
`looked back on at different scales. Figure 5 shows a sequence
`of snapshots as the view is zoomed into the current year. This
`visualization was created by a Tcl script which reads in a file
`with a simple format
`specifying
`starting and ending dates
`along with text or images.
`
`PHYSICS AND METAPHOR
`of Pad++ is part of
`As we mentioned earlier,
`the exploration
`the development
`of a more general
`strategy
`for
`interface
`design. Our goal
`is to move beyond mimicking
`the mecha-
`nisms of earlier media and start to more fully exploit
`the radi-
`cal new mechanisms
`that computation
`provides, We think it
`provides an effective complement
`to the more traditional met-
`aphor-based
`approaches. While
`an informational
`physics
`strategy for interface design may certainly involve metaphor,
`we think there is much that
`is distinctive
`about a physics-
`based perspective. As an interface strategy,
`it can be distin-
`guished from a metaphor-based strategy in at least four ways.
`
`their use, Pre-Coperni-
`First, metaphors necessarily pre-exist
`cans could never have used the metaphor of the solar system
`for describing the atom.
`In designing interfaces, one is limited
`to the metaphorical
`resources at hand,
`In addition,
`the meta-
`phorical
`reference must be familiar
`to work. An unfamiliar
`interface metaphor
`is functionally
`no metaphor at all. One can
`never design metaphors the way one can design self-consis-
`tent physical descriptions
`of appearance and behavior. Thus,
`as an interface design strategy, physics offer designabllity
`and
`tailorabWy
`that metaphor does not.
`
`concepts. When
`bridging
`Second, metaphors are temporary
`In the same way that
`lin-
`they become ubiquitous,
`they die.
`guistic metaphors lose their metaphorical
`impact
`(e.g.,fiot
`of
`the mountain or leg oftalie),
`successful metaphors also wind
`up as dead metaphors (e.g. file, menu, window, desktop). The
`familiarity
`provided by the metaphor during earlier stages of
`use gives way to a familiarity with the interface due to actual
`experience.
`
`Thus, after awhile, even in the case of metaphor-based inter-
`faces, it is the actual details of appearance and behavior
`(i.e.
`the physics)
`rather
`than any overarching metaphor
`that
`form
`much of
`the substantive knowledge
`of an experienced
`user.
`Any restrictions that are imposed on the behaviors of the enti-
`ties of the interface to avoid violations of the initial metaphor
`are potential
`restrictions
`of
`functionality
`that may have been
`employed
`to better support
`the users’
`tasks and allow the
`interface to continue to evolve along with the users increasing
`competency.
`
`The pervasiveness
`
`of dead metaphors
`
`such as files, menus,
`
`24
`
`UIST ’94
`
`Marina del Rey, California
`
`Petitioner Exhibit 1016, Page 8
`
`

`

`of informa-
`Third, since the sheer amount and complexity
`tion with which we need to interact continues to grow, we
`require interface design strategies that scale. Metaphor
`is
`not such a scaling
`strategy. Physics
`is. Physics
`scales to
`organize
`greater and greater
`complexity
`by uniform appli-
`cation
`of sets of simple
`laws.
`In contrast,
`the greater
`the
`complexity
`of
`the metaphorical
`reference,
`the less likely
`it
`is that any particular
`structural
`correspondence
`between
`be useful.
`metaphorical
`target and reference will
`
`is clear that metaphors can be harmful as well
`it
`Fourth,
`since they may well
`lead users to import
`as helpful
`knowledge not supported by the interface. There are cer-
`tainly metaphorical
`aspects associated with a physics-
`based strategy. Our point
`is not
`that metaphors are not
`useful but that they may restrict
`the range of interfaces we
`consider.
`
`a
`There are, of course, also costs associated in following
`physics-based design strategy. One cost is that designers
`can no longer
`rely on users’
`familiarity
`with the meta-
`phorical
`reference and this has learnability
`consequences.
`However,
`the power of metaphor
`comes early in usage
`and is rapidly superseded by the power of actual experi-
`ence. Furthermore,
`since empirical
`knowability
`naturally
`follows from a physics perspective, we can begin to ques-
`tion and quantify how much experimentation will be nec-
`essary to learn the designed-in
`principles,
`how many
`inductive steps will be required and of what kinds. Thus,
`one might want
`to focus on easily discoverable
`physics.
`As is the case with metaphors, all physics are not created
`equally discoverable or equally fitted to the requirements
`of human cognition.
`
`CONCLUSION
`interface
`Pad++, a zooming graphical
`We implemented
`substrate,
`focusing on efficiency
`and expandability.
`By
`implementing
`several efficiency mechanisms which act in
`concert, we are able to maintain high frame-rate interac-
`tion with very large databases. This development
`is part
`of an exploration
`of an informational
`physics perspective
`for interface design.
`
`in collaboration with NYU, continuing
`We are currently,
`the Pad++ substrate as well as starting
`development
`of
`work in several application
`domains,
`such as history-
`enriched digital objects.
`
`ACKNOWLEDGEMENTS
`and his students,
`We would
`like to thank Ken Perlin
`David Fox and Matthew Fuchs, at NYU for enjoyable
`discussions
`and for seeding out
`interest
`in multiscale
`interfaces. We especially appreciate the support we have
`received from Craig Wler as part of ARPA’s new HCI
`Ini-
`tiative. This will allow us to continue our Pad++ research
`collaboration with Bellcore and NYU. We also would like
`to acknowledge other members of the Computer Graphics
`and Interactive Media Research Group at Bellcore
`for
`
`many discussions shared during our continuing
`the best cheeseburger.
`
`search for
`
`REFERENCES
`Ronald M. Baecker, Human Factors and Typography for
`[1]
`More Readable Programs, ACM Press, 1990.
`
`[2]
`
`[3]
`
`[4]
`
`[5]
`
`[6]
`
`[7]
`
`[8]
`
`Benjamin B. Bederson, Larry Stead, and James D. Hollan,
`Pad++: Advances in Multiscale Interfaces,
`In Proceed-
`ings of CHI’94 Human Factors
`in Computing Sys-
`tems Conference Companion,
`ACIWSIGCHI,
`1994,
`pp. 315-316.
`
`Eric A. Bier, Maureen C, Stone, Ken Pier, William Bux-
`ton, and Tony D. DeRose. Toolglass
`and Magic Lenses:
`In Proceedings
`of 1993
`The See-Through
`Interface,
`ACM SIGGRAPH Conference, pp. 73-80.
`
`Stuart K. Card, George G. Robertson, and Jock D. Mack-
`inlay. The Information Visualizer, an Information Work-
`space, In Proceedings
`of CHI’91 Human Factors
`in
`Computing Systems, ACM/SIGCHI,
`1991, pp. 181-188.
`
`Sue T. Dumais, George W. Fumas,
`Steve Deerwester,
`Tom K. Landauer, and Ray Harshman.
`Indexing by Latent
`Journal
`of American
`Socie~ of
`Semantic Analysis.
`Information
`Science, 41,1990,
`pp. 391-407.
`
`Informat-
`of
`Spatial Management
`William C. Donelson.
`In Proceedings of 1978 ACM SIGGRAPH Confer-
`ion,
`ence, pp. 203-209.
`
`Stephen G. Elck, Joseph L. Steffen, and Eric E. Sumner,
`Jr, Seesoft
`- A Tool
`for Visualizing
`Line-Oriented
`Soft-
`IEEE Transactions
`on Software Engi-
`ware Statistics,
`neering, Vol. 18(1 1), pp. 957-968, November,
`1992.
`
`and George W. Fur-
`Kim M. Fairchild, Steven E. Poltmck,
`Graphic Representa-
`nas. SernNet:
`Three-Dimensional
`in Cognitive Science
`tions of Large Knowledge
`Bases,
`and its Applications
`for Human-Computer
`Interac-
`tion, Lawrence Erlbaum Associates,
`1988.
`
`[9]
`
`In Pro-
`Fisheye Views,
`George W. Fumas, Generalized
`ceedings of CHI’86 Human Factors
`in Computing
`Systems, ACM/SK3CHI,
`1986, pp. 16-23.
`
`Recommending
`videos@bellcore.tom:
`C. Hill,
`[10] William
`and evaluating
`items on the basis of communal
`history-of-
`use. Bellcore
`Technical Report
`#TM-ARH-023560,
`Morristown,
`NJ 07960, 1994.
`
`and
`[11] William C. Hill, James D. Hollan, David Wroblewski,
`In Proceed-
`Tlm McCandless, Edit Wear and Read Wear,
`ings of CHI’92 Human Factors
`in Computing Sys-
`tems, ACM/SIGCHI,
`1992, pp. 3-9.
`
`[12] William C. Hill
`Digital Objects,
`
`and James D. Hollan, History-Enriched
`in press.
`
`[13] James D. Hollan, Elaine Rich, William Hill, David Wrob-
`lewski, Wayne Wilner,
`Kent Wittenburg,
`Jonathan Gru-
`din, and Members of the Human Interface Laboratory. An
`Introduction
`to HITS: Human
`Interface
`Tool Suite,
`in
`Intelligent
`User
`Interfaces,
`(Sullivan
`& Tyler, Eds),
`1991, pp. 293-337.
`
`November 2-4, 1994
`
`UIST ’94
`
`25
`
`Petitioner Exhibit 1016, Page 9
`
`

`

`[14] James D. Hollan and Scott Stornetta, Beyond Being There,
`In
`Proceedings
`of CHI’92 Human Factors
`in Computing
`Systems, ACIWSIGCHI,
`1992, pp. 119-125.
`(also appeared as
`in Groupware
`and Computer Sup-
`a chapter
`in Readings
`ported Cooperative Work (Becker, Ed.), 1993, pp. 842-848.
`
`and Mark Johnson, Metaphors We Live By.
`[15] George Lakoff
`University of Chicago Press, 1980.
`
`[16] John K. Ousterhout, Tel and the Tk Toolkit, Addison Wesley,
`1994.
`
`to
`Approach
`[17] Ken Perlin and David Fox. Pad An Alternative
`In Proceedings of 1993 ACM SIG-
`the Computer
`Interface,
`GRAPH Conference, pp. 57-64.
`
`. ..4....–.-.
`and Eric A. Bier. The Mov-
`r 181 Maureen C. Stone. Ken Fishkin.
`in Proceedings
`of
`Tool,
`able Filter
`as a User
`Interfa&
`CHI’94 Human Factors
`in Computing Systems, ACMI
`SIGCHI,
`1994.
`
`com-
`graphical
`[19 Ivan E. Sutherland. Sketchpad: A man-machine
`In Proceedings
`of
`the Spn”ng Joint
`munications
`systems,
`Computer Conference, 1963, pp. 329-346, Baltimore, MD:
`Spartan Books.
`
`26
`
`UIST ’94
`
`Marina del Rey, California
`
`Petitioner Exhibit 1016, Page 10
`
`