Pad++: A Zooming Graphical Interface
`for Exploring Alternate Interface Physics
`
`Benjamin B. Bederson™
`Bell Communications Research
`445 South Street - MRE 2D-336
`Morristown, NJ 07960
`(bederson@bellcore.com)
`
`James D. Hollan
`Computer Science Department
`University of New Mexico
`Albuquerque, NM 87131
`(hollan @cs.unm.edu)
`
`KEYWORDS
`Interactive user interfaces, multiscale interfaces, zooming
`interfaces, authoring, information navigation, hypertext,
`information visualization, information physics.
`
`ABSTRACT
`Wedescribe the current status of Pad++, a zooming graphical
`interface that we are exploring as an alternative to traditional
`window and icon-based approachesto 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 designstrategies.
`
`INTRODUCTION
`If interface designers are to move beyond windows,icons,
`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.
`
`There are numerousbenefits to metaphor-based approaches,
`but they also lead designers to employ computation primarily
`to mimic mechanismsof older media. 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.
`
`For the last few years we have been exploring a different
`strategy for interface design to help focus on novel mecha-
`nisms enabled by computation rather than on mimicking
`mechanismsof 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 madeordistributed for direct com-
`mercial advantage, the ACM copyright notice and thetitle 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/orspecific permission.
`
`© 1994 ACM 0-89791-657-3/94/0011....$3.50
`
`of viewing interface design as the developmentof a physics
`of appearance and behavior for collections of informational
`objects.
`
`For example, an effective informational physics might
`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
`papersare 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 waysit can influencefuture use.
`
`Following an informational physics strategy has lead us to
`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 makesit 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 being viewed butalso in the code from whichit
`was derived.
`
`This informational physics strategy has also lead us to explore
`new physicsfor 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, Albuquereque, NM 87131, beder-
`son@cs.unm.edu.
`
`
`
`November 2-4, 1994
`
`UIST ‘94
`
`1
`
`17
`
`CYPRESS 1016
`CYPRESS 1016
`
`1
`
`

`

`high-end graphics workstations to PDAsand Set-top boxes.
`Here we describe the motivation behind the Pad++ develop-
`ment, report the status of the current implementation, and
`present someprototype applications.
`
`MOTIVATION
`It is a truism of modern life that there is much more informa-
`tion 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
`somewhatparadoxical that while we continuously process
`massive amounts of perceptual data as we experience the
`world, we have perceptual accessto very little of the informa-
`tion that resides within our computing systemsorthat is
`reachable via network connections. In addition, this informa-
`tion, unlike the world around us, is rarely presented in ways
`that reflect either its rich structure or dynamic character.
`
`Weenvision a muchricher world of dynamic persistent infor-
`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.
`
`Onephysics central to Pad++ supports viewing information at
`different scales and attempts to tap into our natural spatial
`waysof thinking. The information presentation problem
`addressed is how to provide effective access to a large body of
`information on a much smaller display. Furnas [9] explored
`degree ofinterest functions to determine the information visi-
`ble at various distances from a central focal area. There is
`muchto recommend the general approach of providing a cen-
`tral focus area of detail surrounded by a periphery that places
`the 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 informa-
`tion that is similar to the early work at MCC on HITS[13] and
`the recent work of moveablefilters at Xerox [3][18].
`
`The ability to makeit easier and more intuitive to find specific
`information in large dataspaces is one of the central motiva-
`tions for Pad++. The traditional approachis to filter or recom-
`mend a subset of the data, hopefully producing a small
`enoughdataset for the user to effectively navigate. Two recent
`examples of work of this nature are latent semantic indexing
`[5] and a video recommenderservice based on shared ratings
`with other viewers [10].
`
`Pad++ is complementary to these filtering approaches in that
`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 largest and most obvious, while placing
`related but lower rated information nearby and smaller.
`
`DESCRIPTION
`Pad++ is a general-purpose substrate for exploring visualiza-
`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
`Tel/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 coloredtext, text files, hypertext, graphics, and
`images.
`
`We have written a simple drawing application using Pad++
`that supports interactive drawing and manipulation of objects
`as well loading of predefined or programmatically created
`objects. This application producedall the figures depicted in
`this paper.
`
`The basic user interface for Pad++ uses a three button mouse.
`Theleft 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 entertext,
`etc. The middle button zoomsin and the right button zooms
`out. Pad++ always zooms around the currentcursor 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 thefirst motion of the mouse after the button
`press determine the direction of the zooming.
`
`Pad++ is a natural substrate for representing abstraction of
`objects using what we term semantic zooming. It is natural to
`see the details of an object when zoomed in and viewingit up
`close. When zoomed out, however, instead of simply seeing a
`scaled down versionof 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 waysto describe this type of object. Thefirst is to
`have different objects, each of whichis visible at different,
`non-overlapping, zooms. This method is supported with the-
`minsize and -maxsize options described in the Tcl/Tk Section.
`The second, and preferred 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
`Ourfocus in the current implementation has been to provide
`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
`becomeslarge and the scene gets complicated. In many appli-
`cations, speed is important, but notcritical to functionality. In
`Pad++, however, the interface paradigm is inherently based
`on interaction. The searching strategy is to visually explore
`
`
`
`18
`
`UIST ‘94
`
`2
`
`Marina del Rey, California
`
`2
`
`

`

`
`
`Figure 1: Sequence of snapshots(from left to right and top to bottom) as the view is
`zoomedin to a hand-drawnpicture.
`
`the dataspace, so it is essential that interactive frame rates be
`maintained.
`
`IMPLEMENTATION
`We implemented Pad++ in C++. It runs on either of two
`graphics systems: the Silicon Graphics computers graphics
`languagefacilities (GL); and standard X. The X version runs
`on SGI’s, Suns, PC’s running Linux, and should be trivially
`portable to other standard Unix® 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
`
`size and complexity increases, we implemented several stan-
`dard efficiency methods, which taken together create a power-
`ful system. We have successfully loaded over 600,000 objects
`and maintainedinteractiverates.
`
`Briefly, the implemented efficiency methodsinclude:
`
`* Spatial Indexing: Create a hierarchy of objects based on
`bounding boxes to quickly index to visible objects.
`
`* Restructuring: Automatically restructure the hierarchy
`of objects to maintain a balanced tree whichis necessary
`for the fastest indexing.
`
`© Spatial Level-Of-Detail: Render only the detail needed,
`do not render what can not be seen.
`
`© Clipping: Only render the portions of objects that are
`actually visible.
`
`Runixis a registered trademark of Unix Systems Laboratories, Inc.
`
`® Refinement: Render fast with low resolution while navi-
`
`
`
`November 2-4, 1994
`
`UIST ‘94
`
`19
`
`3
`
`

`

`gating andrefine the image whenstill.
`
`* Adaptive Render Scheduling: Keep the zoomingrate
`constant even as the frame rate changes.
`
`Onechallenge in navigating through any large dataspace is
`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 implementedin 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.
`
`An important interactive interface issue when accessing
`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-
`basethat 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.
`
`Anassociated conceptis that of ephemeral objects. Objects in
`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
`In traditional window-based systems, there is no graphical
`depiction of the relationship among windows even when
`there is a strong semantic relationship. This problem typically
`comesup with hypertext. In many hypertext systems, clicking
`on a hyperlink brings up a new window(oralternatively
`replaces the contents of the existing window). While thereis
`an importantrelationship between these windows(parent and
`child), this relationship is not represented.
`
`We have begun experimenting with multiscale layouts of
`hypertext where we graphically represent the parent-child
`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.
`
`The user interface for accessing hypertext in Pad++ is quite
`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.
`
`Pad++ can read in hypertextfiles written in the Hypertext
`Markup Language (HTML), the language used to describe
`objects in the well-known hypertext system, MOSAIC (from
`
`the NCSA at the University of Illinois). While we do not yet
`follow links across the network, we can effectively use Pad++
`as an alternative viewer to MOSAICwithin our file system.
`Figure 2 shows a snapshot with one of the author’s home-
`page loaded andseverallinks followed.
`
`INTERFACE TO TCL/TK
`Pad++ is built as a new widget for Tk which provides for sim-
`ple accessto all of its features through Tcl, an interpreted
`scripting language. Tcl and Tk [16] are an increasingly popu-
`lar combination of scripting language and Motif-like library
`for creating graphical user interfaces and applications without
`writing any C code. The Tclinterface to Pad++ is designed to
`be very similar to the interface to the Tk Canvas widget-
`which provides a surface for drawing structured graphics.
`
`While Pad++ does not implement everything in the Tk Can-
`vas yet, it adds many extra features - notably those supporting
`multiscale objects and zooming. In addition, it supports
`images,textfiles, 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.
`
`Since Tclis interpreted and thus slower than compiled code,it
`is important to understand whatits 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:
`
`* Create objects: Slow -
`
`Tclis fine
`
`¢ Handle events: Medium - Small amount of Tel is ok
`
`© Render scene: Fast -
`
`C++ only
`
`Becauseall rendering is done in C++, and typically only a
`few lines of Tcl are written to handle each event, Pad++ main-
`tains interactive rates despite its link to Tcl. Tcl is quite good,
`however, for reading and parsing inputfiles, and creating and
`laying out graphical multiscale objects.
`
`The Tcl interface to Pad++ is, as previously mentioned, quite
`similar to that of the Tk canvas, and is summarized here to
`give a feel for whatit is like to program Pad++. Every object
`is assigned a unique integerid. 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 objectid or to a tag,
`in whichcaseit will apply to all objects that share that tag -
`implicitly grouping objects. Each Pad++ widget has its own
`name. Ali Pad++ commandsstart with the name of the wid-
`get, and in the examplesthat follow, the nameof the widgetis
`-pad.
`
`Examples:
`
`* A red rectangle with a black outline is created whose cor-
`ners are at the points (0, 0) and (2, 1):
`.pad create rectangle 0 0 2 1 -fill red
`-outline black
`
`* Put item number5 at the location (3, 3), make the object
`
`
`
`20
`
`UIST “94
`
`4
`
`Marina del Rey,California
`
`4
`
`

`

`OsgeeesaBELVee
`
`wae
`ene “greweee ope 28057!
`wo’ Beddarsonr‘NicenePage5;
`fBEeH,tsihbadfPoe eeeph
`p
`pedeEReefore Pets
`Ps
`aeesefe
`eeLUie EERE,ae
`Safe
`%
`oy
`PE AS oe, be a
`od
`epigeasesSlrSs
`Sf ME siaba
`osLeSEEM oad
`iM
`ed
`ee.
`$
`Be LEDeeiges
`BEBE
`yeaa i, eyABE gid
`om ee/egigeUEPE
`o
`oe:
`waeDOxs
`orOSvos
`Nee a
`Aare
`3
`ye Sessiree
`.
`ofke
`nf ake,
`rads gt se
`ee og af
`eeniia Lhe,
`eaeeepeeie
`=MoEEaS
`CO
`eee
`eetoeLie
`Fey, SUES.hob
`e
`Pig Ms"heaaBe
`Beees eee, |
`DIELS
`ORES es
`ne
`LOLGEReM,DOELG,
`zs OLSeitBe Es PSdispute eed Re ey
`BIteeeh ee
`as
`Dblala gillENTE we LAB
`og
`OeehbhoyPete
`va
`DiEETpthGAGE:SSETINSIETBs
`Paes,Heeas .
`poke
`ae
`,
`
`Lesswa
`
`4
`
`‘”
`
`Figure 2: Hypertext. Links are followed and placed on the surface to the side, and made smaller.
`
`
`
`November 2—4, 1994
`
`UIST “94
`
`5
`
`21
`
`5
`
`

`

`twice as big, and make the object anchored at that point
`on its northwest corner:
`.pad itemconfig 5 -anchor nw -place *3 3 2”
`
`milliseconds for the animation:
`-pad center 37 500
`
`* Return the list of object ids that contain the text “foo”
`-pad find withtext foo
`
`© Specify that item number 5 should only be visible when
`its largest dimension is greater than 20 pixels andless
`Figure 3 shows a Tk interface based on these commands.
`than 100 pixels.
`Entering text in the top entry region returnsalist of objects
`-pad itemconfig 5 -minsize 20 -maxsize 100
`that contain that text. Double clicking on any of these objects
`smoothly animates the view to the specified object.
`
`* Makeall items with tag £00 turn blue when the left button
`of the mouse is pressed over any of those objects:
`-pad bind foo <ButtonPress>
`{.pad itemconfig foo -fill blue}
`
`As mentioned previously, Pad++ is a natural environmentte
`represent abstraction through semantic zooming. Objects can
`be represented differently depending on their size by defining
`procedural objects. A procedural object is one thatis ren-
`dered as a result of a special procedure (as opposed to pre-
`defined static objects such as lines or text). Pad++ supports
`Tel 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 whenit is small,
`and “Jan Feb Mar”in black whenitisalittle bigger:
`proc makeCalendar {}
`{
`-pad create tcl ~script “cal” -bb “calBB”
`
`The smooth animationsinterpolate in pan and zoom to bring
`the view to the specified location. If the end point, however, is
`more than one screen width away from thestarting point, the
`animation zoomsout to a point midway betweenthestarting
`and ending points, far enough outso that both points are visi-
`ble. The animation then smoothly zoomsin to 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 zoomedout which covers much more ground than pan-
`ning while zoomed in.
`
`salBeara |
`
`Figure 3: Content based search
`
`VISUALIZATIONS
`Webuilt a Pad++ directory browser to explore how smooth
`zoomingandthe variousefficiency mechanismshelp in view-
`ing a large hierarchical database, and to experiment with
`multi-scale layouts. The Pad++ directory browser provides a
`graphicalinterface 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 byfile type. Both directories and files show their filena-
`mesas labels when the useris 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 andout ofthe
`directory tree, or by using the content based search mecha-
`nisms described above. Zoomingintoa file automatically
`loads the text inside the colored square and it can then be
`edited and annotated.
`
`Weare able to load in a directory tree with over 600,000
`objects, and maintain interactive animation rates of about 10
`framesper second.Spatial indexing allows us to explore very
`
`} p
`
`roc cal {} {
`set view [.pad move_to]
`set size [lindex $view 2}
`if ($size < .1} {
`-pad set_color red
`-pad set_linewidth 2
`-pad draw_text
`* 1993” 0 0
`} else {
`-pad set_color black
`-pad set_linewidth 1
`-pad draw_text “Jan Feb Mar” 0 0
`
`} p
`
`{
`roc calBB {}
`return *0 0 11 1°
`
`} N
`
`AVIGATION
`Finding information on the Pad++ surface is obviously very
`important as intuitive navigation through large dataspacesis
`oneofits primary motivations. Pad++ support visual search-
`ing with zooming in addition to traditional mechanisms, such
`as content-based search.
`
`Somebasic navigation and searching mechanismsare pro-
`vided at the Tcl interface for the application programmer. A
`few basic onesare:
`
`* Smoothly go to the location (1, 0) at zoom of5, and take
`1000 milliseconds for the animation:
`-pad move_to 10 5 1000
`
`* Smoothly go to the location such that object #37 is cen-
`tered, and fills three quarter’s of the screen, and take 500
`
`re
`
`22
`
`UIST “94
`
`6
`
`Marina del Rey, California
`
`6
`
`

`

`
`
`Figure 4: Directory browser snapshot
`
`
`
`November 2-4, 1994
`
`UIST “94
`
`7
`
`23
`
`7
`
`

`

`Another dataset we looked at with Pad++ is a timeline of
`interesting products, events, and papers in computer technol-
`ogy and userinterfaces. History naturally lendsitself to being
`looked back on atdifferent 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 readsinafile
`with a simple format specifying starting and ending dates
`along with text or images.
`
`large databases while keeping the search time fast, since we
`renderonly the visible portion of the scene. While navigating
`with Pad++, very small objects are not drawn andlarger ones
`are drawn with reduced resolution. The objects are then
`refined and drawn at high resolution when the user stops
`changing the view.
`
`PHYSICS AND METAPHOR
`As we mentioned earlier, the exploration of Pad++ is part of
`the developmentof a more generalstrategy for interface
`design. Our goal is to move beyond mimicking the mecha-
`nisms of earlier media andstart to more fully exploit the radi-
`cal new mechanismsthat computation provides. We think it
`provides an effective complementto the moretraditional 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.
`
`First, metaphors necessarily pre-exist their use. Pre-Coperni-
`cans could never have used the metaphorof 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 metaphoris functionally no metaphorat 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 designability and
`tailorability that metaphor doesnot.
`
`Second, metaphors are temporary bridging concepts. When
`they become ubiquitous, they die. In the same waythatlin-
`guistic metaphors lose their metaphorical impact(e.g., foot of
`the mountain or leg of table), successful metaphors also wind
`up as dead metaphors (e.g.file, menu, window, desktop). The
`familiarity provided by the metaphorduring 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 metaphorthat form
`muchof the substantive knowledge of an experienced user.
`Anyrestrictions 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 suchas files, menus,
`
`and windows may well restrict us from thinking about alter-
`native organizations of computation. New conceptionsofper-
`sistent objects and organizations of entities into units less
`monolithic than that of unstructuredfiles are indeed in con-
`
`flict with older metaphorical notions.
`
`Figure 5: Timeline. Sequence of snapshots
`(from top to bottom) as the view is zoomedin.
`
`
`
`24
`
`UIST “94
`
`8
`
`Marina del Rey, California
`
`8
`
`

`

`Third, since the sheer amount and complexity of informa-
`tion with which we need to interact continues to grow, we
`require interface design strategies that scale. Metaphoris
`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
`metaphorical target and reference will be useful.
`
`Fourth, it is clear that metaphors can be harmful as well
`as helpful since they may well lead users to import
`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 butthat they mayrestrict the range of interfaces we
`consider.
`
`There are, of course, also costs associated in following a
`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 comesearly in usage
`and is rapidly superceded by the powerof 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.
`Asis the case with metaphors, all physics are not created
`equally discoverable or equally fitted to the requirements
`of human cognition.
`
`CONCLUSION
`We implemented Pad++, a zooming graphical interface
`substrate, focusing on efficiency and expandability. By
`implementing several efficiency mechanisms whichactin
`concert, we are able to maintain high frame-rate interac-
`tion with very large databases. This developmentis part
`of an exploration of an informational physics perspective
`for interface design.
`
`Weare currently, in collaboration with NYU,continuing
`developmentof the Pad++ substrate as well as starting
`work in several application domains, such as history-
`enriched digital objects.
`
`ACKNOWLEDGEMENTS
`We would like to thank Ken Perlin and his students,
`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 Wier as part of ARPA’s new HCIIni-
`tiative. This will allow us to continue our Pad++ research
`collaboration with Bellcore and NYU.Wealso wouldlike
`to acknowledge other members of the Computer Graphics
`and Interactive Media Research Groupat Bellcore for
`
`many discussions shared during our continuing search for
`the best cheeseburger.
`
`REFERENCES
`[1] Ronald M. Baecker, Human Factors and Typography for
`More Readable Programs, ACM Press, 1990.
`
`[2] 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, ACM/SIGCHI, 1994,
`pp. 315-316.
`
`[3] Eric A. Bier, Maureen C. Stone, Ken Pier, William Bux-
`ton, and Tony D. DeRose. Toolglass and Magic Lenses:
`The See-Through Interface, In Proceedings of 1993
`ACM SIGGRAPHConference, pp. 73-80.
`
`[4] 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.
`
`[5] Steve Deerwester, Sue T. Dumais, George W. Furnas,
`Tom K. Landauer, and Ray Harshman.Indexing by Latent
`Semantic Analysis. Journal of American Society of
`Information Science, 41, 1990, pp. 391-407.
`
`[6] William C. Donelson. Spatial Management of Informa-
`tion, In Proceedings of 1978 ACM SIGGRAPHConfer-
`ence, pp. 203-209.
`
`(7] Stephen G. Eick, Joseph L. Steffen, and Eric E. Sumner,
`Jr, Seesoft - A Tool for Visualizing Line-Oriented Soft-
`ware Statistics, IEEE Transactions on Software Engi-
`neering, Vol. 18 (11), pp. 957-968, November, 1992.
`
`[8] Kim M.Fairchild, Steven E. Poltrock, and George W. Fur-
`nas. SemNet: Three-Dimensional Graphic Representa-
`tions of Large Knowledge Bases, in Cognitive Science
`and its Applications for Human-Computer Interac-
`tion, Lawrence Erlbaum Associates, 1988.
`
`[9] George W. Furnas, Generalized Fisheye Views, In Pro-
`ceedings of CHI’86 Human Factors in Computing
`Systems, ACM/SIGCHIL, 1986,pp. 16-23.
`
`[10] William C. Hill, videos@bellcore.com: Recommending
`and evaluating items on the basis of communalhistory-of-
`use. Bellcore Technical Report #TM-ARH-023560,
`Morristown, NJ 07960, 1994.
`
`[{11] William C. Hill, James D. Hoilan, David Wroblewski, and
`Tim McCandless, Edit Wear and Read Wear, In Proceed-
`ings of CHI’92 Human Factors in Computing Sys-
`tems, ACM/SIGCHI, 1992,pp. 3-9.
`
`[12] William C. Hill and James D. Hollan, History-Enriched
`Digital Objects, 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
`
`9
`
`

`

`[14] James D. Hollan and Scott Stornetta, Beyond Being There, In
`Proceedings of CHI’92 Human Factors in Computing
`Systems, ACM/SIGCHI,1992, pp. 119-125. (also appeared as
`a chapter in Readings in Groupware and Computer Sup-
`ported Cooperative Work (Becker, Ed.), 1993, pp. 842-848.
`
`{15] George Lakoff and Mark Johnson, Metaphors We Live By.
`University of Chicago Press, 1980.
`
`[16] John K. Ousterhout, Tcl and the Tk Toolkit, Addison Wesley,
`1994,
`
`[17] Ken Perlin and David Fox. Pad: An Alternative Approach to
`the ComputerInterface, In Proceedings of 1993 ACM SIG-
`GRAPH