`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, author-
`ing, information navigation, hypertext, information visu-
`alization, information physics.
`
`ABSTRACT
`We describe the current status of Pad++, an infinite reso-
`lution sketchpad that we are exploring as an alternative to
`traditional window and icon-based approaches to inter-
`face design. We discuss the motivation for Pad++,
`describe the implementation, and present prototype appli-
`cations. In addition, we introduce an informational phys-
`ics strategy for interface design and briefly compare it
`with metaphor-based design strategies.
`
`INTRODUCTION
`If interface designers are to move beyond windows,
`icons, menus, and pointers to explore a larger space of
`interface possibilities, additional ways of thinking about
`interfaces that go beyond the desktop metaphor are
`required. The exploration of virtual 3D worlds is one
`alternative. It follows quite naturally from more tradi-
`tional direct manipulation approaches to interface design
`and involves similar underlying metaphors, although they
`are enriched by the greater representational possibilities
`afforded by moving from the desktop to richer 3D worlds.
`
`There are numerous benefits to metaphor-based
`approaches, but they also lead designers to employ com-
`putation primarily to mimic mechanisms of older media.
`While there are important cognitive, cultural, and engi-
`neering reasons to exploit earlier successful representa-
`tions, 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 mech-
`anisms enabled by computation rather than on mimicking
`mechanisms of older media. Informally the strategy con-
`
`Published in UIST ‘94
`
`sists of viewing interface design as the development of a
`physics of appearance and behavior for collections of
`informational objects.
`
`For example, an effective informational physics might
`arrange for useful representation 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. Fre-
`quently consulted papers are at the top of piles on our
`desks. Use dog-ears the corners and stains the surface of
`index cards and catalogs. All these provide representa-
`tional cues as a natural product of doing but the physics of
`older media limit what can be recorded and the ways it
`can influence future use.
`
`Following an informational physics strategy has lead us to
`explore history-enriched digital objects [12][13]. Record-
`ing 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 cor-
`rect a bug not only in the piece of code being viewed but
`also in the code from which it was derived.
`
`This informational physics strategy has also lead us to
`explore new physics for interacting with graphical data. In
`collaboration with Ken Perlin, we have designed a succes-
`sor to Pad [18]. This system, Pad++, will be the basis for
`exploration of novel interfaces for information visualiza-
`tion and browsing in a number of complex information-
`intensive domains. The system is being designed to oper-
`ate on platforms ranging from high-end graphics worksta-
`tions to PDAs and Set-top boxes. Here we describe the
`motivation behind the Pad++ development, report the sta-
`tus of the current implementation, and present some pro-
`totype applications.
`
`APPLE 1018
`
`1
`
`
`
`MOTIVATION
`It is a truism of modern life that there is much more infor-
`mation 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 avail-
`ability of information because of new network and com-
`putational technologies. It is somewhat paradoxical that
`while we continuously process massive amounts of per-
`ceptual data as we experience the world, we have percep-
`tual access to very little of the information that resides
`within our computing systems or that is reachable via net-
`work connections. In addition, this information, unlike
`the world around is, is rarely presented in ways that
`reflect either its rich structure or dynamic character.
`
`We envision a much richer world of dynamic persistent
`informational entities that operate according to multiple
`physics specifically designed to provide cognitively facile
`access. The physics need to be designed to exploit seman-
`tic relationships explicit and implicit in information-
`intensive tasks and in our interaction with these new
`kinds of computationally-based work materials.
`
`One physics central to Pad++ supports viewing informa-
`tion at multiple 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 structure of information on a much smaller display.
`Furnas [10] explored degree of interest functions to deter-
`mine the information visible at various distances from a
`central focal area. There is much to recommend the gen-
`eral approach of providing a central 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, per-
`haps 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 information that is similar to the early
`work at MCC on HITS[14] and the recent work of move-
`able filters at Xerox [3][19].
`
`The ability to make it easier and more intuitive to find
`specific information in large dataspaces is one of the cen-
`tral motivations for Pad++. The traditional approach is to
`filter or recommend a subset of the data, hopefully pro-
`ducing a small enough dataset for the user to effectively
`navigate. Two examples of work of this nature are latent
`semantic indexing [6] and a video recommender service
`based on shared ratings with other viewers [11].
`
`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 obvi-
`ous, while placing related but lower rated information
`nearby and smaller.
`
`DESCRIPTION
`Pad++ is a general-purpose substrate for exploring visual-
`izations of graphical data with a zooming interface. While
`Pad++ is not an application itself, it directly supports cre-
`ation and manipulation of multiscale graphical objects,
`and navigation through the object space. It is imple-
`mented as a widget for Tcl/Tk [17](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.
`
`We have written a simple drawing application using
`Pad++ that supports interactive drawing and manipula-
`tion of objects as well loading of predefined or program-
`matically 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 draw-
`ing application 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. For systems with two button
`mice, we have experimented with various mechanisms
`for mapping zooming in and out to a single button. Typi-
`cally, this involves having the first motion of the mouse
`after the button press determine the direction of the zoom-
`ing.
`
`Pad++ is a natural substrate for representing abstraction
`of objects using what we term semantic zooming. It is nat-
`ural to 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 effective to see a different representation
`of it. Perlin [18] described a prototype zooming calendar
`with this notion. There are 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 Tcl/Tk Section. The second, and
`preferred method, is to describe a procedural object that
`renders itself differently depending on its viewing size. It
`is possible to prototype procedural objects with Tcl as
`described below.
`
`RECENT ADVANCES
`Our focus in the current implementation has been to pro-
`vide smooth zooming in a system that works with very
`
`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.
`
`large graphical datasets. The nature of the Pad++ inter-
`face requires consistent high frame-rate interactions, even
`as the dataspace becomes large and the scene gets compli-
`cated. In many applications, speed is important, but not
`critical to functionality. In Pad++, however, the interface
`paradigm is inherently based on interaction. The search-
`ing strategy is to visually explore the dataspace, so it is
`essential that interactive frame rates be maintained.
`
`IMPLEMENTATION
`We implemented Pad++ in C++. There are two versions:
`one uses Silicon Graphics computers graphics language
`facilities (GL), and the other uses standard X. The X ver-
`sion runs on SGI’s, Suns, PC’s running Linux, and should
`be trivially portable to other standard Unix system. Pad++
`is implemented 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 standard efficiency methods, which taken together
`create a powerful system. We have successfully loaded
`over 600,000 objects and maintained interactive rates.
`
`Briefly, the implemented efficiency methods include:
` • Spatial Indexing: Create a hierarchy of objects based
`on bounding boxes to quickly index to visible objects.
` • Restructuring: Automatically restructure the hierar-
`chy of objects to maintain a balanced tree which is
`necessary for the fastest indexing.
`
`3
`
`
`
` • Spatial Level-Of-Detail: Render only the detail
`needed, do not spend time rendering what can not be
`seen.
` • Clipping: Only render the portions of objects that are
`actually visible.
` • Refinement: Render fast with low resolution while
`navigating and refine the image when still.
` • Adaptive Render Scheduling: Keep the zooming
`rate constant even as the frame rate changes.
`
`One challenge 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. The rough animation or jumpy zooming as
`implemented in the original Pad [18] can be disorienting
`and thus not provide the most effective support for the
`cognitive and perceptual processing required for interac-
`tive information visualization and navigation.
`
`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 database 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 load-
`ing is complete, items appear in the appropriate place.
`
`An associated concept is that of ephemeral objects.
`Objects in Pad++ which are representations of data on
`disk can be labeled ephemeral. These objects are auto-
`matically 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 graphi-
`cal depiction of the relationship among windows even
`when there is a strong semantic relationship. This prob-
`lem typically comes up with hypertext. In many hypertext
`systems, clicking on a hyperlink brings up a new window
`with the linked text (or alternatively replaces the contents
`of the existing window). While there is an important rela-
`tionship between these windows (parent and child), this
`relationship is not represented.
`
`We have begun experimenting with multiscale layouts of
`hypertext traversals where we graphically represent the
`parent-child relationships between links. When a hyper-
`link is selected, the linked data is loaded to the side and
`made smaller, and the view is animated to center the new
`
`data object.
`
`The user interface for accessing hypertext in Pad++ is
`quite simple. The normal navigation techniques are avail-
`able, 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 parent.
`
`Pad++ can read in hypertext files written in the Hypertext
`Markup Language (HTML), the language used to
`describe 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 effec-
`tively use Pad++ as an alternative viewer to MOSAIC
`within our file system. Figure 2 shows a snapshot with the
`MOSAIC home-page loaded and several links followed.
`
`INTERFACE TO TCL/TK
`Pad++ is built as a new widget for Tk which provides for
`simple access to all of its features through Tcl, an inter-
`preted scripting language. Tcl and Tk [17] are an increas-
`ingly popular combination of scripting language and
`Motif-like library for creating graphical user interfaces
`and applications without writing any C code. The Tcl
`interface to Pad++ is designed to be very similar to the
`interface to the Tk Canvas widget - which provides a sur-
`face for drawing structured graphics.
`
`While Pad++ does not implement everything in the Tk
`Canvas 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 sev-
`eral 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 Tcl.
`
`Since Tcl is interpreted and thus slower than compiled
`code, it is important to understand what its role is in a
`real-time animation 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 -
`Tcl is fine
` • Handle events: Medium - Small amount of Tcl is ok
` • Render scene: Fast -
`C++ only
`Because all rendering is done in C++, and typically only a
`few lines of Tcl are written to handle each event, Pad++
`maintains interactive rates despite its link to Tcl. Tcl is
`quite good, however, for reading and parsing input files,
`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
`
`4
`
`
`
`Figure 2: Hypertext. Links are followed and
`placed on the surface to the side, and made
`smaller.
`
`5
`
`
`
`.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
`dataspaces is one of its primary motivations. Pad++ sup-
`port visual searching with zooming in addition to tradi-
`tional mechanisms, such as content-based search.
`
`Some basic navigation and searching mechanisms are
`provided at the Tcl interface for the application program-
`mer. A few basic ones are:
`
` • Smoothly go to the location (1, 0) at zoom of 5, and
`take 1000 milliseconds for the animation:
`.pad move_to 1 0 5 1000
` • Smoothly go to the location such that object #37 is
`centered, and fills three quarter’s of the screen, and
`take 500 milliseconds for the animation:
`.pad center 37 500
` • Return the list of object ids that contain the text “foo”
`.pad find withtext foo
`
`Figure 3: Content based search
`
`Figure 3 shows a Tk interface based on these commands.
`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.
`
`here to give a feel for what it is like to program Pad++.
`Every object is assigned a unique integer id. In addition,
`the user may associate an arbitrary list of text tags with
`each object. Every command can be directed to either a
`specific object id or to a tag, in which case it will apply to
`all objects that share that tag. This gives a simple method
`for grouping objects. Each Pad++ widget has its own
`name. All Pad++ commands start with the name of the
`widget, and in the examples that follow, the name of the
`widget is .pad.
`
`Examples:
` • A red rectangle with a black outline is created whose
`corners are at the points (0, 0) and (2, 1):
`.pad create rectangle 0 0 2 1 -fill red
`-outline black
` • Put item number 5 at the location (3, 3), make the
`object twice as big, and make the object anchored at
`that point on its northwest corner:
`.pad itemconfig 5 -anchor nw -place “3 3 2”
` • Specify that item number 5 should only be visible
`when its largest dimension is greater than 20 pixels
`and less than 100 pixels.
`.pad itemconfig 5 -minsize 20 -maxsize 100
` • Make all items with tag foo 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 environment
`to 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 rendered as a result of a special procedure
`(as opposed to predefined 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 (nec-
`essary 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 the text “Jan Feb Mar” in black when it is a little big-
`ger:
`
`proc makeCalendar {} {
`.pad create tcl -script “cal” -bb “calBB”
`
`} 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 {
`
`6
`
`
`
`Figure 4: Directory browser snapshot
`
`7
`
`
`
`The smooth animations interpolate 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 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 visible. The animation then smoothly
`zooms in to the destination. This both 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 panning while
`zoomed in.
`
`VISUALIZATIONS
`We built a Pad++ directory browser to explore how
`smooth zooming and the various efficiency mechanisms
`help in viewing 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 colored by file type. Both
`directories and files show their filenames 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 direc-
`tory structure can be done by zooming in and out of the
`directory tree, or by using the content based search mech-
`anisms described above. Zooming into a file automati-
`cally loads the text inside the colored square and it can
`then be edited and annotated.
`
`We are able to load in a directory tree with over 600,000
`objects, and maintain interactive animation rates of about
`10 frames per second. Spatial indexing allows us to
`explore very large databases while keeping the search
`time fast, since we render only the visible portion. While
`navigating with Pad++, very small objects are not drawn
`and larger ones are drawn with reduced resolution. The
`reduced resolution objects are refined when the user stops
`changing the view.
`
`Another dataset we looked at with Pad++ is a timeline of
`interesting products, events, and papers in computer tech-
`nology and user interfaces. History naturally lends itself
`to being 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 specify-
`ing starting and ending dates along with text or images.
`
`Figure 5: Timeline. Sequence of snapshots
`(from top to bottom) as the view is zoomed
`in.
`
`8
`
`
`
`Physics and Metaphor
`As we mentioned earlier, the exploration of Pad++ is part
`of the development of a more general strategy for inter-
`face design. Our goal is to move beyond mimicking the
`mechanisms of earlier media and start to more fully
`exploit the radical new mechanisms that computation
`provides. We think it provides an effective complement to
`the more traditional metaphor-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 distinguished from a meta-
`phor-based strategy in at least four ways.
`
`First, metaphors necessarily pre-exist their use. Pre-
`Copernicans could never have used the metaphor of the
`solar system for describing the atom. In designing inter-
`faces, one is limited to the metaphorical resources at
`hand. In addition, the metaphorical 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-consistent physi-
`cal descriptions of appearance and behavior. Thus, as an
`interface design strategy, physics offer designability and
`tailorability that metaphor does not.
`
`Second, metaphors are temporary bridging concepts.
`When they become ubiquitous, they die. In the same way
`that linguistic metaphors lose their metaphorical impact
`(e.g., foot of the mountain or leg of table), successful met-
`aphors also wind up as dead metaphors (e.g. file, menu,
`window, desktop). The familiarity provided by the meta-
`phor 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
`interfaces, it is the actual details of appearance and behav-
`ior (i.e. the physics) rather than any overarching metaphor
`that form much of the substantive knowledge of an expe-
`rienced user. Any restrictions that are imposed on the
`behaviors of the entities of the interface to avoid viola-
`tions of the initial metaphor are potential restrictions of
`functionality that may have been employed to better sup-
`port 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, and windows may well restrict us from thinking
`about alternative organizations of computation. New con-
`ceptions of persistent objects and organizations of entities
`into units less monolithic than that of unstructured files
`are indeed in conflict with older metaphorical notions.
`
`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. 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
`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 but that they may restrict 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 comes early in usage
`and is rapidly superceded 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
`We implemented Pad++, a zooming graphical interface
`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.
`
`We are currently, in collaboration with NYU, continuing
`development of 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 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 search for
`the best cheeseburger.
`
`9
`
`
`
`puter Supported Cooperative Work (Becker, Ed.), 1993,
`842-848.
`
`[16] George Lakoff and Mark Johnson, Metaphors We Live By.
`University of Chicago Press, 1980.
`
`[17] John K. Ousterhout, Tcl and the Tk Toolkit, Addison Wes-
`ley, 1994.
`
`[18] Ken Perlin and David Fox. Pad: An Alternative Approach
`to the Computer Interface, Proceedings of 1993 ACM
`SIGGRAPH Conference, 57-64.
`
`[19] Maureen C. Stone, Ken Fishkin, and Eric A. Bier. The
`Movable Filter as a User Interface Tool, to appear in Pro-
`ceedings of ACM SIGCHI’94.
`
`[20] Ivan E. Sutherland. Sketchpad: A man-machine graphical
`communications systems, Proceedings of the Spring Joint
`Computer Conference, 1963, 329-346, Baltimore, MD:
`Spartan Books.
`
`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, Proceedings
`of 1994 ACM SIGCHI Conference.
`
`[3] Eric A. Bier, Maureen C. Stone, Ken Pier, William Bux-
`ton, and Tony D. DeRose. Toolglass and Magic Lenses:
`The See-Through Interface, Proceedings of 1993 ACM
`SIGGRAPH Conference, 73-80.
`
`[4] Stuart K. Card, George G. Robertson, and Jock D. Mack-
`inlay. The Information Visualizer, an Information Work-
`space, Proceedings of ACM Human Factors in Computing
`Systems Conference (CHI ‘91), 181-188.
`
`[5] Muriel Cooper, Personal Communication, 1994.
`
`[6] Steve Deerwester, Sue T. Dumais, George W. Furnas,
`Tom K. Landauer, and Ray Harshman. Indexing by Latent
`Semantic Analysis. Journal of American Society of Infor-
`mation Science, 41, 1990, pp.391-407.
`
`[7] William C. Donelson. Spatial Management of Informa-
`tion, Proceedings of 1978 ACM SIGGRAPH Conference,
`203-209.
`
`[8] Stephen G. Eick, Joseph L. Steffen, and Eric E. Sumner, Jr,
`Seesoft - A Tool for Visualizing Line-Oriented Software
`Statistics, IEEE Transactions on Software Engineering,
`Vol. 18 (11), pp. 957-968, November, 1992.
`
`[9] 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
`Interaction,
`Lawrence Erlbaum Associates, 1988.
`
`[10] George W. Furnas, Generalized Fisheye Views, Proceed-
`ings of 1986 ACM SIGCHI Conference, pp. 16-23.
`
`[11] William C. Hill, videos@bellcore.com: Recommending
`and evaluating items on the basis of communal history-of-
`use. Bellcore Technical Report #TM-ARH-023560, Mor-
`ristown, NJ, 1994.
`
`[12] William C. Hill, James D. Hollan, David Wroblewski, and
`Tim McCandless, Edit Wear and Read Wear, Proceedings
`of ACM SIGCHI’92, pp. 3-9.
`
`[13] William C. Hill and James D. Hollan, History-Enriched
`Digital Objects, in press.
`
`[14] 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.
`
`[15] James D. Hollan and Scott Stornetta, Beyond Being There,
`Proceedings of ACM SIGCHI’92, pp. 119-125. (also
`appeared as a chapter in Readings in Groupware and Com-
`
`10
`
`