“
Once the product's task is known, design the interface first; then implement to the interface design..... As far as the customer is concerned, the interface is the the product.
”
-- Jef Raskin, Cited by Malcolm McCullough in Digital Ground, 2004
Authoritative overview of End-User Development (EUD) including 4 HD video interviews filmed in Rome, Italy. EUD is really all about democratization of computing.
UIST is the premier forum for innovations in developing human-computer interfaces. The symposium brings together user-interface researchers and practitioners with an interest in techniques, tools, and technology for constructing high-quality, innovative user interfaces.
The following articles are from "Proceedings of the 4th annual ACM symposium on User interface software and technology":
Articles
p. 107-115
Wang, Haiying and Green, Mark (1991): An Event-Object Recovery Model for Object-Oriented User Interfaces. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 107-115. Available online
“An important aspect of interactive systems is the provision of a recovery facility that allows the user to reverse the effects of his interactions with the system. Due to differences between object-oriented and non-object-oriented methodologies, user recovery approaches used for non-object-oriented software are not suitable for object-oriented software. This paper presents an event-object user recovery model for the construction of recovery facilities in object-oriented user interfaces. Our approach divides traditional history/command lists into per-object lists which fit well with object-oriented structure. Unique features of this framework are the hierarchical structure of the local recovery objects that reflect the application structure, its simple semantics, and its ease of implementation, which greatly reduces the effort required by the interface builder to incorporate it into existing object-oriented user interface structures. We introduce this framework by describing the event-object model, defining the protocol used by the local facilities to perform user recovery, and presenting examples of how the framework is used.”
Pausch, Randy, Young II, Nathaniel R. and DeLine, Robert (1991): SUIT: The Pascal of User Interface Toolkits. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 117-125. Available online
“User interface support software, such as UI toolkits, UIMSs, and interface builders, are currently too complex for undergraduates. Tools typically require a learning period of several weeks, which is impractical in a semester course. Most tools are also limited to a specific platform, usually either Macintosh, DOS, or UNIX/X. This is problematic for students who switch from DOS or Macintosh machines to UNIX machines as they move through the curriculum. The situation is similar to programming languages before the introduction of Pascal, which provided an easily ported, easily learned language for undergraduate instruction. SUIT (the Simple User Interface Toolkit), is a C subroutine library which provides an external control UIMS, an interactive layout editor, and a set of standard screen objects. SUIT applications run transparently across Macintosh, DOS, UNIX/X, and Silicon Graphics platforms. Through careful design and extensive user testing of the system and its documentation, we have been able to reduce learning time. We have formally measured that new users are productive with SUIT in less than three hours. SUIT currently has over one hundred students using it for undergraduate and graduate course work and for research projects.”
Goldberg, David and Goodisman, Aaron (1991): Stylus User Interfaces for Manipulating Text. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 127-135. Available online
“This paper is concerned with pen-based (also called stylus-based) computers. Two of the key questions for such computers are how to interface to handwriting recognition algorithms, and whether there are interfaces that can effectively exploit the differences between a stylus and a keyboard/mouse. We describe prototypes that explore each of these questions. Our text entry tool is designed around the idea that handwriting recognition algorithms will always be error prone, and has a different flavor from existing systems. Our prototype editor goes beyond the usual gesture editors used with styli and is based on the idea of leaving the markups visible.”
Kurtenbach, Gordon and Buxton, William (1991): Issues in Combining Marking and Direct Manipulation Techniques. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 137-144. Available online
“The direct manipulation paradigm has been effective in helping designers create easy to use mouse and keyboard based interfaces. The development of flat display surfaces and transparent tablets are now making possible interfaces where a user can write directly on the screen using a special stylus. The intention of these types of interfaces is to exploit users' existing handwriting, mark-up and drawing skills while also providing the benefits of direct manipulation. This paper reports on a test bed program which we are using for exploring hand-marking types of interactions and their integration with direct manipulation interactions.”
Hudson, Scott E. and Yeatts, Andrey K. (1991): Smoothly Integrating Rule-Based Techniques into a Direct Manipulation Interace Builder. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 145-153. Available online
“Work in automating the production of user interface software has recently concentrated on two distinct approaches: systems that provide a direct manipulation editor for specifying user interfaces and systems that attempt to automatically generate much or all of the interface. This paper considers how a middle ground between these approaches can be constructed. It presents a technique whereby the rule-base inference methods used in many automatic generation systems can be smoothly integrated into a direct manipulation interface builder. This integration is achieved by explicitly representing the results of inference rules in the direct manipulation framework and by using semantic snapping techniques to give the user direct feedback and interactive control over the application of rules.”
Zanden, Brad Vander, Myers, Brad A., Giuse, Dario and Szekely, Pedro (1991): The Importance of Pointer Variables in Constraint Models. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 155-164. Available online
“Graphical tools are increasingly using constraints to specify the graphical layout and behavior of many parts of an application. However, conventional constraints directly encode the objects they reference, and thus cannot provide support for the dynamic runtime creation and manipulation of application objects. This paper discusses an extension to current constraint models that allows constraints to indirectly reference objects through pointer variables. Pointer variables permit programmers to create the constraint equivalent of procedures in traditional programming languages. This procedural abstraction allows constraints to model a wide array of dynamic application behavior, simplifies the implementation of structured object and demonstrational systems, and improves the storage and efficiency of highly interactive, graphical applications. It also promotes a simpler, more effective style of programming than conventional constraints. Constraints that use pointer variables are powerful enough to allow a comprehensive user interface toolkit to be built for the first time on top of a constraint system.”
Takahashi, Shin, Matsuoka, Satoshi and Yonezawa, Akinori (1991): A General Framework for Bi-Directional Translation between Abstract and Pictorial Data. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 165-174. Available online
“The merits of direct manipulation (DM) are now widely recognized. However, DM interfaces incur high cost in their creation. To cope with this problem, we present a model of bi-directional translation between internal abstract data of applications and pictures, and create a prototype system TRIP2 based on this model. Using this model, general mapping from abstract data to pictures, and from pictures to abstract data, is realized merely by giving declarative mapping rules, allowing fast and effortless creation of DM interfaces. We also apply the prototype system to the generation of the interfaces for kinship diagrams, graph diagrams, and an Othello game.”
Kataoka, Yutaka, Morisaki, Masato, Kuribayashi, Hiroshi and Ohara, Hiroyoshi (1991): A Model for Input and Output of Multilingual Text in a Windowing Environment. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 175-183. Available online
“A multilingual Input/Output (I/O) system has been designed based on topological studies of writing conventions of major world languages. Designed as a layered structure, it unifies common features of writing conventions and is intended to ease international and local functionalities. The input module of the internationalization layer converts phonograms to ideograms. The corresponding output module displays position-independent characters and position-dependent characters. The localization layer positions highly language-specific functions outside the structure. These functions are integrated as tables and servers to add new languages without the necessity of compilation. The I/O system interactively generates both stateful and stateless code sets. Beyond the boundaries of the POSIX locale model, the system generates ISO 2022, ISO/DIS 10646, and Compound Text, defined for the interchange encoding format in X11 protocols, for basic polyglot text processing. Possessing the capability of generating multilingual code sets, this I/O system clearly shows that code sets should be selected by applications with purposes beyond the selection of one element from a set of localization. Likewise, functionality and functions relating to text manipulation in an operating system should be determined by such applications. A subset of this I/O system was implemented in the X window system as a basic X11R5 I/O capability by supplying basic code set generation and string manipulation to avoid interference from operating systems. To ensure the possibility of polyglot string manipulation, the I/O system clearly should be implemented separately from the operating system with its limitations.”
Morisaki, Masato, Kawada, Etsuo, Kuribayashi, Hiroshi, Kuwari, Seiji and Narita, Masahiko (1991): XJp System: An Internationalized Language Interface for the X Window System. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 185-193. Available online
“This paper discusses the internationalization of the X Window System developed by the MIT X consortium. The main purpose is to enable X Window System Release 4 (X11R4) and earlier versions to support Asian languages, primarily Japanese, Chinese, and Korean. Unlike English and other European-based languages, Asian languages involve ideographic character manipulation. X Window System X11R4 and earlier versions can output such ideograms when the corresponding fonts are provided, but they have no corresponding input feature. Asian language input thus involves more than one keystroke to input a single ideogram, e.g., Japanese-language input uses romaji-kana-kanji conversion. This paper proposes an ideogram input architecture on the X Window System and discusses the interfaces between conversion systems and X application programs. Like the X Window System, our input-conversion feature is oriented to a distributed network environment.”
Liang, Jiandong, Shaw, Christopher D. and Green, Mark (1991): On Temporal-Spatial Realism in the Virtual Reality Environment. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 19-25. Available online
“The Polhemus Isotrak is often used as an orientation and position tracking device in virtual reality environments. When it is used to dynamically determine the user's viewpoint and line of sight (e.g. in the case of a head mounted display) the noise and delay in its measurement data causes temporal-spatial distortion, perceived by the user as jittering of images and lag between head movement and visual feedback. To tackle this problem, we first examined the major cause of the distortion, and found that the lag felt by the user is mainly due to the delay in orientation data, and the jittering of images is caused mostly by the noise in position data. Based on these observations, a predictive Kalman filter was designed to compensate for the delay in orientation data, and an anisotropic low pass filter was devised to reduce the noise in position data. The effectiveness and limitations of both approaches were then studied, and the results shown to be satisfactory.”
Hsu, S. C. (1991): A Flexible Chinese Character Input Scheme. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 195-200. Available online
“A very flexible and easy-to-use scheme which possesses unique advantages over existing systems is presented in this article. The scheme is based on the partitioning of a character into parts. A character is inputted by specifying the sequence of character parts descriptions, which is then matched against the standard sequences of the characters the character set. A character part is either described with a unique key or its stroke count. The matching algorithm allows the characters to be partitioned flexibly and inputted in many different ways. An automatic binding mechanism offers very high adaptability to the input style of the user. The user need not remember all the key bindings before he can input Chinese and the scheme is also capable of tolerating many variations in character style and/or errors.”
Vlissides, John and Tang, Steven H. (1991): A Unidraw-Based User Interface Builder. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 201-210. Available online
“Ibuild is a user interface builder that lets a user manipulate simulations of toolkit objects rather than actual toolkit objects. Ibuild is built with Unidraw, a framework for building graphical editors that is part of the InterViews toolkit. Unidraw makes the simulation-based approach attractive. Simulating toolkit objects in Unidraw makes it easier to support editing facilities that are common in other kinds of graphical editors, and it keeps the builder insulated from a particular toolkit implementation. Ibuild supports direct manipulation analogs of InterViews' composition mechanisms, which simplify the specification of an interface's layout and resize semantics. Ibuild also leverages the C++ inheritance mechanism to decouple builder-generated code from the rest of the application. And while current user interface builders stop at the widget level, ibuild incorporates Unidraw abstractions to simplify the implementation of graphical editors.”
Myers, Brad A. (1991): Separating Application Code from Toolkits: Eliminating the Spaghetti of Call-Backs. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 211-220. Available online
“Conventional toolkits today require the programmer to attach call-back procedures to most buttons, scroll bars, menu items, and other widgets in the interface. These procedures are called by the system when the user operates the widget in order to notify the application of the user's actions. Unfortunately, real interfaces contain hundreds or thousands of widgets, and therefore many call-back procedures, most of which perform trivial tasks, resulting in a maintenance nightmare. This paper describes a system that allows the majority of these procedures to be eliminated. The user interface designer can specify by demonstration many of the desired actions and connections among the widgets, so call-backs are only needed for the most significant application actions. In addition, the call-backs that remain are completely insulated from the widgets, so that the application code is better separated from the user interface.”
Wolber, David and Fisher, Gene L. (1991): A Demonstrational Technique for Developing Interfaces with Dynamically Created Objects. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 221-230. Available online
“The development of user interfaces is often facilitated by the use of a drawing editor. The user interface specialist draws pictures of the different "states" of the interface and passes these specifications on to the programmer. The user interface specialist might also use the drawing editor to demonstrate to the programmer the interactive behavior that the interface should exhibit; that is he might demonstrate to the programmer the actions that an end-user can perform and the graphical manner by which the application should respond to the end-user's stimuli. From the specifications, and the in-person demonstrations, the programmer implements a prototype of the interface. DEMO is a User Interface Development System (UIDS) that eliminates the programmer from the above process. Using an enhanced drawing editor, the user interface specialist demonstrates the actions of the end-user and the system, just as he would if the programmer were watching. However no programmer is necessary: DEMO records these demonstrations, makes generalizations from them, and automatically generates a prototype of the interface.”
Wellner, Pierre D. (1991): The DigitalDesk Calculator: Tangible Manipulation on a Desk Top Display. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 27-33. Available online
“Today's electronic desktop is quite separate from the physical desk of the user. Electronic documents lack many useful properties of paper, and paper lacks useful properties of electronic documents. Instead of making the electronic desktop more like the physical desk, this work attempts the opposite: to give the physical desk electronic properties and merge the two desktops into one. This paper describes a desk with a computer-controlled camera and projector above it. The camera sees where the user is pointing, and it reads portions of documents that are placed on the desk. The projector displays feedback and electronic objects onto the desk surface. This DigitalDesk adds electronic features to physical paper, and it adds physical features to electronic documents. The system allows the user to interact with paper and electronic objects by touching them with a bare finger (digit). Instead of "direct" manipulation with a mouse, this is tangible manipulation with a finger. The DigitalDesk Calculator is a prototype example of a simple application that can benefit from the interaction techniques enabled by this desktop. The paper begins by discussing the motivation behind this work, then describes the DigitalDesk, tangible manipulation, and the calculator prototype. It then discusses implementation details and ends with ideas for the future of tangible manipulation.”
Robertson, George G., Henderson Jr, D. Austin and Card, Stuart K. (1991): Buttons as First Class Objects on an X Desktop. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 35-44. Available online
“A high-level user interface toolkit, called XButtons, has been developed to support on-screen buttons as first class objects on an X window system desktop. With the toolkit, buttons can be built that connect user interactions with procedures specified as arbitrary Unix Shell scripts. As first class desktop objects, these buttons encapsulate appearance and behaviour that is user tailorable. They are persistent objects and may store state relevant to the task they perform. They can also be mailed to other users electronically. In addition to being first class desktop objects, XButtons are gesture-based with multiple actions. They support other interaction styles, like the drag and drop metaphor, in addition to simple button click actions. They also may be concurrently shared among users, with changes reflected to all users of the shared buttons. This paper describes the goals of XButtons and the history of button development that led to XButtons. It also describes XButtons from the user's point of view. Finally, it discusses some implementation issues encountered in building XButtons on top of the X window system.”
Bier, Eric A. (1991): EmbeddedButtons: Documents as User Interfaces. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 45-53. Available online
“Recent electronic document editors and hypertext systems allow users to create customized user interfaces by adding user-pressable buttons to on-screen documents. Positioning these buttons is easy because users are already familiar with the use of document editors. Unfortunately, the resulting user interfaces often exits only in stand-alone document systems, making it hard to integrate them with other applications. Furthermore, because buttons are usually treated as special document objects, they cannot take advantage of document editor formatting and layout capabilities to create their appearance. This paper describes the EmbeddedButtons architecture, which makes it easy to integrate buttons into documents and to use the resulting documents for a variety of user interface types. EmbeddedButtons allows arbitrary document elements to behave as buttons. Documents can be linked to application windows to serve as application control panels. Buttons can store and display application state to serve as mode indicators. New button classes, editors, and applications can be added dynamically.”
Henry, Tyson R. and Hudson, Scott E. (1991): Interactive Graph Layout. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 55-64. Available online
“This paper presents a novel methodology for viewing large graphs. The basic concept is to allow the user to interactively navigate through large graphs learning about them in appropriately small and concise pieces. An architecture is present to support graph exploration. It contains methods for building custom layout algorithms hierarchically, interactively decomposing large graphs, and creating interactive parameterized layout algorithms. As a proof of concept, examples are drawn from a working prototype that incorporates this methodology.”
Henry, Tyson R., Hudson, Scott E., Yeatts, Andrey K., Myers, Brad A. and Feiner, Steven K. (1991): A Nose Gesture Interface Device: Extending Virtual Realities. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 65-68. Available online
“This paper reports on the development of a nose-machine interface device that provides real-time gesture, position, smell and facial expression information. The DATANOSE{trade} Data AtomaTa CORNUCOPIA pNeumatic Olfactory I/O-deviSE Tactile Manipulation [Olsen86, Myers91] allows novice users without any formal nose training to perform complex interactive tasks.”
Dewan, Prasun and Choudhary, Rajiv (1991): Primitives for Programming Multi-User Interfaces. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 69-78. Available online
“We have designed a set of primitives for programming multi-user interfaces by extending a set of existing high-level primitives for programming single-user interfaces. These primitives support both collaboration-transparent and collaboration-aware multi-user programs and allow existing single-user programs to be incrementally changed to corresponding multi-user programs. The collaboration-aware primitives include primitives for tailoring the input and output to a user, authenticating users, executing code in a user's environment and querying and setting properties of it, and tailoring the user interface coupling. We have identified several application-independent user groups that arise in a collaborative setting and allow the original single-user calls to be targeted at these groups. In addition, we provide primitives for defining application-specific groups. Our preliminary experience with these primitives shows that they can be used to easily implement collaborative tasks of a wide range of applications including message systems, multi-user editors, computer conferencing systems, and coordination systems. In this paper, we motivate, describe, and illustrate these primitives, discuss how primitives similar to them can be offered by a variety of user interface tools, and point out future directions for work.”
Bier, Eric A. and Freeman, Steve (1991): MMM: A User Interface Architecture for Shared Editors on a Single Screen. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 79-86. Available online
“There is a growing interest in software applications that allow several users to simultaneously interact with computer applications either in the same room or at a distance. Much early work focused on sharing existing single-user applications across a network. The Multi-Device Multi-User Multi-Editor (MMM) project is developing a user interface and software architecture to support a new generation of editors specifically designed to be used by groups, including groups who share a single screen. Each user has his or her own modes, style settings, insertion points, and feedback. Screen space is conserved by reducing the size and number of on-screen tools. The editors use per-user data structures to respond to multi-user input.”
Patterson, John F. (1991): Comparing the Programming Demands of Single-User and Multi-User Applications. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 87-94. Available online
“Synchronous multi-user applications are designed to support two or more simultaneous users. The RENDEZVOUS system is an infrastructure for building such multi-user applications. Several multi-user applications, such as a tic-tac-toe game, a multi-user CardTable application, and a multi-user whiteboard have been or are being constructed with the RENDEZVOUS system. We argue that there are at least three dimensions of programming complexity that are differentially affected by the programming of multi-user applications as compared to the programming of single-user applications. The first, concurrency, addresses the need to cope with parallel activities. The second dimension, abstraction, addresses the need to separate the user-interface from an underlying application abstraction. The third dimension, roles, addresses the need to differentially characterize users and customize the user-interface appropriately. Certainly, single-user applications often deal with these complexities; we argue that multi-user applications cannot avoid them.”
Feiner, Steven K. and Shamash, Ari (1991): Hybrid User Interfaces: Breeding Virtually Bigger Interfaces for Physically Smaller Computers. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 9-17. Available online
“While virtual worlds offer a compelling alternative to conventional interfaces, the technologies these systems currently use do not provide sufficient resolution and accuracy to support detailed work such as text editing. We describe a pragmatic approach to interface design that provides users with a large virtual world in which such high-resolution work can be performed. Our approach is based on combining heterogeneous display and interaction device technologies to produce a hybrid user interface. Display and interaction technologies that have relatively low resolution, but which cover a wide (visual and interactive) field are used to form an information surround. Display and interaction technologies that have relatively high resolution over a limited visual and interaction range are used to present concentrated information in one or more selected portions of the surround. These high-resolution fields are embedded within the low-resolution surround by choosing and coordinating complementary devices that permit the user to see and interact with both simultaneously. This allows each embedded high-resolution interface to serve as a "sweet spot" within which information may be preferentially processed. We have developed a preliminary implementation, described in this paper, that uses a Reflection Technology Private Eye display and a Polhemus sensor to provide the secondary low-resolution surround, and a flat-panel display and mouse to provide the primary high-resolution interface.”
Rowe, Lawrence A., Konstan, Joseph A., Smith, Brian C., Seitz, Steve and Liu, Chung (1991): The PICASSO Application Framework. In: Rhyne, James R. (ed.) Proceedings of the 4th annual ACM symposium on User interface software and technology Hilton Head, South Carolina, United States, 1991, Hilton Head, South Carolina, United States. pp. 95-105. Available online
“PICASSO is a graphical user interface development system that includes an interface toolkit and an application framework. The application framework provides high-level abstractions including modal dialog boxes and non-modal frames and panels similar to conventional programming language procedures and co-routines. These abstractions can be used to define objects that have local variables and that can be called with parameters. PICASSO also has a constraint system that is used to bind program variables to widgets, to implement triggered behaviors, and to implement multiple views of data. The system is implemented in Common Lisp using the Common Lisp Object System and the CLX interface to the X Window System.”
We have decided to give away world-class educational materials
because we believe that universal access to high quality education is key to the building
of peace, sustainable social and economic development, and intercultural dialogue.
To calculate just have much we have saved you, our wonderful readers, we compare our free encyclopedia to two
books we love:
As you are reading our encyclopedia on your iPad/tablet (and saving a few trees), we estimate that the price would be $90 if sold as an eBook.
With that number, we can calculate how much money we have saved our readers, based on calculating the number of readers.
How we calculate readership
Because of our online and tablet/iPad approach to publishing, we are able to precisely measure reading behaviour across hundreds of parameters in realtime: Anything from reading
speed, drop-off points in the text, reader demographics, and much more.
Based on our server logs and the Google Analytics API,
we calculate the number of readers as described in the calculation method below.
A reader is not the same as a simple pageview and a reader is not the same as a
website visitor (as described in our calculation method below).
We calculate readership for two types of readers:
Readers that have read our whole encyclopedia, much the same way you read a printed book
Readers that have reader an individual chapter
Calcalution method: How we define a reader
First we use the Google Analytics API to get a report of the number of unique human visitors to a chapter/page. Google runs its business on ads and thus completely relies on the ability to distinguish between a human visitor and an automated request. If not, you could earn millions on automating clicks on Google Ads.
We then compare that number to our Apache webserver logs, which report the much higher number of actual visits to a chapter/page (both human and automated). We calculate the difference in percent, which we call an "exaggeration factor", which we use in step 6 below.
With a large part of the visitors excluded, we further exclude any visitor who:
has not remained on the page for at least 3 minutes (this factor is calculated by recording visit durations of 1000 randomly selected visitors) or has not printed the page (i.e. has not visited the printerfriendly version of the chapter/page)
has not scrolled the page (this factor is calculated by recording scroll movements on 1000 randomly selected visitors)
We then further exclude "double readers", i.e. readers who read a portion of a chapter and then returns in,
say, a week or a month to read the rest.
Although this person's reading activity spans multiple server sessions, the person is only counted as a single reader.
We categorize a "double reader" as a visitor who:
visits a page, or multiple pages, across multiple server sessions
qualifies to be defined as a reader, cf step 1-3 above, in all server sessions
uses the same originating IP address
We then subtract 5% from the final number to counter-balance a last remaining factor, namely the situation where one reader reads a chapter on his/her tablet
using a WiFi connection (and counted as one reader) but then picks up his other tablet using a 3G dongle
(with another IP address) and re-reads some of the chapter. That will equal two readers, not one. We have no way
of calculating how many times this situation arises, but to be on the safe side we subtract 5%
from the final number.
We then take half of the "exaggeration factor" from step 2 and substract from the final number. We do this for no rational reason. We do it only as a further measure to be certain that our number of readers is not inflated.
To qualify as a reader who has read our whole encyclopedia - much the same way you read a printed book - that person must have qualified as a reader (cf. 1-6 above) of at least 80% of the encyclopedia chapters.
As a result, we have eliminated everything from automated requests to the more casual visitors. That leaves us with what we can safely call readers.
User-contributed notes
Give us your opinion! Do you have any comments/additions that you would like other visitors to see?
Add a thoughtful commentary or note to this page !
Changes to this page (conference)
28 May 2003: Added the conference to the bibliography
Page Information
Page maintainer: How to cite/reference this page
URL: http://www.interaction-design.org/references/conferences/proceedings_of_the_4th_annual_acm_symposium_on_user_interface_software_and_technology.html
“
Once the product's task is known, design the interface first; then implement to the interface design..... As far as the customer is concerned, the interface is the the product.
”
-- Jef Raskin, Cited by Malcolm McCullough in Digital Ground, 2004
Authoritative overview of End-User Development (EUD) including 4 HD video interviews filmed in Rome, Italy. EUD is really all about democratization of computing.
