Randall B. Smith

Self: The power of simplicity

Self is a new object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because Self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. Selfs simplicity and expressiveness offer new insights into object-oriented computation.

Effective sounds in complex systems: the ARKOLA simulation

We designed an ecology of auditory icons which worked together to convey information about a complex, demanding simulation task, and observed users collaborating on it with and without sound. Our observations suggest that audio cues can provide useful information about processes and problems, and support the perceptual integration of a number of separate processes into one complex one. In addition, they can smooth the transition between division of labour and collaboration by providing a new dimension of reference. These results suggest that auditory icons can play a significant role in future multiprocessing and collaborative systems.

Experiences with the alternate reality kit: an example of the tension between literalism and magic

This paper presents an overview of the Alternate Reality Kit (ARK), an animated environment for creating interactive simulations. ARK is built upon a physical-world metaphor: all objects have an image, a position, a velocity, and can experience forces. Users manipulate objects with a mouse-operated “hand” which enables them to carry and throw objects, to press buttons, and to operate sliders. The interface features are discussed in light of a general user interface tension between literalism and magic. Literal features are defined to be those that are true to the interfaces metaphor. Literal features enhance an interfaces learnability. Magical features are defined to be those capabilities that deliberately violate the metaphor in order to provide enhanced functionality. Discussion of each ARK feature includes informal observations of early ARK users, an assessment of the features learnability, of its usefulness, and of its position on the magical-literal axis. Even though ARK includes magical features, applications-level users have be trained in a few minutes. Although this paper is about ARK, the tension between literalism and magic raises some interesting questions on its own. Some of these questions are presented briefly in the conclusion.

Directness and liveness in the morphic user interface construction environment

Morphic is a user interface construction environment that strives to embody directness and liveness. Directness means a user interface designer can initiate the process of examining or changing the attributes, structure, and behavior of user interface components by pointing at their graphical representations directly. Liveness means the user interface is always active and reactive-+bjects respond to user actions, animations run, layout happens, and information displays update continuously. Four implementation techniques work together to support directness and liveness in Morphic: structural reification, layout reification, ubiquitous animation, and live editing.

Transparent sharing of Java applets: a replicated approach

People interact together in all aspects of life and, as computers have become prevalent, users seek computer support for their interactions. The WWW provides an unprecedented opportunity for users to interact with each other, and the advent of JavaThfl has created a consistent computing environment to support synchronous collaboration. We describe JAMM, a prototype Java runtime environment that supports the shared use of existing Java applets, thus leveraging the existing base of software for synchronous collaboration. Our approach is based on a replicated architecture, where each user maintains their own copy of the Java applet, and the users’ input events are broadcast to each applet copy. We discuss solutions to certain key problems, such as unanticipated sharing, supporting late-joiners, and replicating input sources other than user inputs (e.g., files, sockets, and random number generators).

Programming as an Experience: The Inspiration for Self

The Self system attempts to integrate intellectual and nonintellectual aspects of programming to create an overall experience. The language semantics, user interface, and implementation each help create this integrated experience. The language semantics embed the programmer in a uniform world of simple objects that can be modified without appealing to definitions of abstractions. In a similar way, the graphical interface puts the user into a uniform world of tangible objects that can be direcdy manipulated and changed without switching modes. The implementation strives to support the world-of-objects illusion by minimizing perceptible pauses and by providing true source-level semantics without sacrificing performance. As a side benefit, it encourages factoring. Although we see areas that fall short of the vision, on the whole, the language, interface, and implementation conspire so that die Self programmer lives and acts in a consistent and malleable world of objects.

Supporting flexible roles in a shared space

People in a group play various roles. Manager, intern, department chair, guest speaker, the woman who knows how the fax machine works, the guy who got the pizza, the person speaking now, the person capturing this on the whiteboard; roles can be formal or informal, long-lived or ephemeral. They can be bestowed by ceremony, or assumed with the invisibility of the taken-for-granted. But it is the interaction of minds that creates and sustains a role: a role is a human construct. Even roles like “mother” or “father”, which would seem to demand certain biological characteristics, cannot be defined at any depth without appeal to social convention. The largely hands-off approach taken by nature seems to work fairly well for groups of humans: when there is confusion or concern about who is playing what role, it is generally good for a group to work it out as a social issue. If roles were encoded solely in human biology or in physical law, life might be simpler but certainly more stulfiying.

A simple and unifying approach to subjective objects

Abstract Most object-oriented languages are objective: an object always responds to the same message in the same way. Subjective objects more closely match naturally occurring systems, and they provide consistent solutions to a wide range of problems, problems that otherwise must be solved by varied and specialized mechanisms. Applying a perspective-receiver symmetry principle in designing the subjectivity semantics of an object-oriented language results in a semantically uncluttered language with a surprisingly wide range of utility. We employ this approach in creating the language Us, a subjective version of Self.

SPOTWorld and the Sun SPOT

We describe the Sun Small Programmable Object Technology, or Sun SPOT. The Sun SPOT is a small wireless computing platform that runs Java directly, with no operating system. The system comes with an on-board set of sensors, and I/O pins for easy connection to external devices. We also describe SPOTWorld, an integrated management and code deployment tool for working with Sun SPOTs.

SELF: the power of simplicity

SELF is an object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because SELF does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. SELFs simplicity and expressiveness offer new insights into object-oriented computation.To thine own self be true. — William Shakespeare laggy