Personal tools
You are here: Home 1997 Vol. 29 No. 4, October 1997 Workshops Special Interest Groups End-User Computing
Document Actions

End-User Computing

Howie Goodell and Carol Traynor

No earlier issue with same topic
Issue
Previous article
Article
SIGCHI Bulletin
Vol.29 No.4, October 1997
Next article
Article
No later issue with same topic
Issue



Introduction

The people who use computers have a detailed understanding of what they are trying to do that is typically wasted because they do not have the tools to incorporate it into the behavior of the standard programs they are running. End-User Computing/End-User Programming refers to environments that enable non-programmers to produce working computer applications[1].

End users program as a mean to an end. They rarely have time or inclination to learn the tools and skills of a professional programmer; so compromises are required. The expressiveness of professional programming languages is traded for usability by a variety of metaphors and tricks. Programming can be done much more easily within the metaphor -- a formula of spreadsheet locations or mathematical symbols; a sequence of GUI actions; a circuit diagram; an application-specific language -- than in a conventional programming language.

Because appropriate metaphors, with their capabilities and limitations, differ widely depending on the users and their purposes, there is no one method of end-user programming. Instead there is a variety of techniques, such as PBD (Programming by Demonstration), visual programming, and many domain-specific languages and formalisms. This SIG attempted to sample this variety, draw some lessons, and plan ways to encourage wider use of end-user programming techniques.

Summary of SIG

Most of the time was devoted to scheduled and impromptu presentations of the participants experiences with end-user programming environments. The 21 attendees represented a range of:

  • Applications
    business, game builders, children's programming tools, virtual world builders, laboratory and industrial automation, Web robots, and design tools.
  • Methods
    from spreadsheet macros to visual rewrite rules; from preference boxes to intelligent agents.
  • Tools
    from standbys like spreadsheets, Visual Basic, and LABVIEW to gleam-in-the-eye research.
  • People
    a wide spectrum of researchers and users.

Scheduled Presentations

Alexander Repenning

ralex@cs.colorado.edu/
http://www.cs.colorado.edu/~l3d/systems/agentsheets

He has tried to make "behavior processors" with which users can construct worlds of programmed agents, just as they use word processors to construct documents. See the CHI97 talk and participatory demo on "Social Behavior Processing", by Alexander Repenning and James Ambach, or browse to his Web page (address above) and follow the link to "Child's Play." Repenning's basic method is graphical rewrite rules. These are "if...then" rules with graphical icons as conditions and actions. For example: IF (picture of car with empty road in front)
THEN (same picture: car moved forward)

A CHI 97 Special Interest Group

causes the car to move down the highway on each simulation cycle until it encounters an obstacle. Analog constructs, such as variables that can be calculated and colors that blend smoothly based on their value, permit more sophisticated simulations. For example, in a bridge-building game the blocks in the bridge turn different shades of red depending on the stress applied to them. Colors in a weather map vary by a model of temperature between recording sites. Using this metaphor, he has found that children can create fairly complex programs, robots, etc.

The major tools that incorporate these principles are Agentsheets and Visual Agen Talk. See http://www.cs.colorado.edu/~l3d/systems/agentsheets

Both are written in Lisp and run only on Macintosh, but a company formed to commercialize them is porting to other platforms including PC Windows. Another thrust of Repenning's group is to incorporate the World-Wide Web: "Simulation meets Browser." For example the temperatures in the above-mentioned weather map are gleaned from a large number of weather sites by a tool that lets users specify where on each Web page to find the temperature(s) of interest. Simulations can be shared across the Web: an agent with its behavior and appearance can be dragged out of a browser and dropped into a an AgentSheets simulation. His most recent innovation (with James Ambach) is Ristretto, a translator which creates an execute-only Java representation of an AgentSheets simulation that can execute on any computer over the Web.

Howie Goodell

hgoodell@tem.teainet.com
http://www.cs.uml.edu/~hgoodell/EndUser

Howie presented a completely user-programmable control environment for computer "chip" production equipment. Every aspect of operation, from controlling robot arms that move silicon wafers through the machine, to detailed control of the processing procedure, to low-level machine configuration and control, can be modified or completely reconfigured by the physicists, engineers and technicians who work with it.

The three tools that enable this are a hardware configuration builder, a screen builder, and an application-specific "sequence language". These have enabled his (admittedly sophisticated) user community to program complex prototype cluster tools (processing chambers grouped around a central robot arm in vacuum) themselves, a job that normally requires a team of programmers. In addition, because all the specific functionality of the machines (which are typically heavily customized) is in the user-programmable layer, the core system can stay orders of magnitude simpler and more reliable.

Denis Lalanne

lalanne@imtsg10.epfl.ch

Dennis is the designer of a research product called COMIND, a sophisticated direct manipulation environment for configuration design. It attempts to factor the design process into human- and machine-suitable tasks. There is no hierarchy or fixed order; at any point the user may flexibly move between computer assistants for design tasks such as parameter definition, brainstorming, tradeoff analysis, conflict elicitation and resolution, and constraint satisfaction solving. There are two kinds of agents: computational agents that process inconsistencies in the design space, and reflective agents that serve as a cognitive map of the user.

In each area the program attempts to do the jobs that are hard for users. For example the parameter definition agent provides a menu of possible rule types, and produces a visualization of the graph that results from the parameters and constraints entered so far. The brainstorming assistant keeps a record of previous sessions and presents possible analogies. The tradeoff assistant provides an editor for specifying which solutions are preferable in an under-constrained problem (where many solutions are possible); the conflict resolution assistant allows visualization of conflicting rules in over-constrained systems (where the parameters entered so far rule out all possible solutions.) Finally, the history assistant ensures loose ends are tied up, and the showcase helps organize a multimedia presentation of the solution.

Jim Larson

Jim_A_Larson@ccm.jf.intel.com
http://labtoys.hbtn.portland.or.us/Idm20Worlds/docs/public

Jim's group is part of an Intel division that attempts to find new uses for personal computers. His group has used Intel's framework of Java classes for distributed applications to create IdMoo (Intel Distributed MOO), a 2D/3D virtual world builder for distributed multiuser games.

Users populate their worlds with characters and determine their characteristics by specifying multiple pictures for their different visible states, and checking boxes to set their personality characteristics. The characters give the illusion of intelligent interaction by communicating their characteristics. For instance fish objects in an aquarium simulation ask nearby creatures, "do you eat"; then a negotiation based on size determines who eats whom, and with what probability. Jim organized a SIG on "Design Issues in `Avatar' Multi-user Virtual Worlds", and presented an interactive demo at CHI.

Dag Svanaes

dags@ifi.ntnu.no

Dag has a long history of research on end-user environments. In 1986 he made an interface builder for teachers; in 1992 he studied the configuration of communication aids for the disabled. Currently he is doing a study of 6th-grade children using Cocoa (formerly KidSim), a study of End-User Programming in Geographical Information Systems (GISs), and an experimental study of tools for constructing interactivity.

Research Questions:

  • Design methodologies (P.D., Analysis of work language)
  • Constructionist approaches, Bricoleur (Levi-Strauss)
  • Domain-specific vs. general tools (concrete-abstract.)
  • Target groups for End-User Programming.

Some results: GIS tools and HyperTalk target the wrong user group. Their difficulty makes them not really suitable for users; they are more suitable for "gardeners" (advanced users). However this group finds their limitations on expressiveness excessive.

Don't be afraid of formal communication systems. However they have to be domain-specific.

Brad Myers

bam@cs.cmu.edu

http://www.cs.cmu.edu/~bam

Brad is a founding father of demonstrational interfaces, with a long history of "semi-precious" interfaces (Peridot, Tourmaline, Garnet, Amulet, etc.!) His group at the Human-Computer Interaction Institute at Carnegie-Mellon University CMU has a web page, http://www.cs.cmu.edu/~bydemo, with links to a variety of research efforts including PBD and a variety of direct-manipulation interface building tools. His interfaces over the years have included text, visualization/charting, and many forms of user interfaces. Some current research:

  • Amulet
  • Game design environment -- Rich McDaniel
  • Web pages (in progress)
  • Visual shell -- F. Modugno
  • Sketching -- Landag (Architecture)
  • Natural Programming -- John Pane (present; see below.)

Informal Presentations

In addition to the scheduled presentations, each attendee doing research or working with end-user programming gave a short description of the work s/he was doing and brief comments about their experiences with end-user programming. More information on the attendees can be found on the new End-User Programming Website, http://www.cs.uml.edu/~hgoodell/EndUser

The authors apologize for anyone whose presentation they have unintentionally left out of the following descriptions.

Bill Bennett uses Word and Excel Macros, and Visual Basic for data analysis and User Interface programming.

Takahiro Yamaguchi uses LABVIEW for control of instruments.

CeCe Lichtenstein works for the United States Government Treasury Dept. Her experience of supporting a group of Quattro Pro and Word Perfect macros was an excellent example of the limitations of end-user programming. She inherited these totally undocumented macros, written by people in the finance department who were now unavailable to help her understand them. Although they had been written years before in a 16-bit DOS environment, they continued to be widely used years later because their function (crunching the numbers required to justify purchases) was still important. Despite the technical hurdles and the fact they had never been written to be ported to new environments or last so long, they needed to be supported. Those of us who write end-user tools need to consider the possibility that some of our users will write programs this successful, and try to make their lives a little easier!

Sumit Bhandari is a student at Ohio State. He builds tools using Visual Basic, HTML, and Director to help architects communicate with their clients.

John Payne of CMU targets kids and adult non-programmers. He is looking at difficulties people have had with programming over last 20 years and how to make "Natural Programming" tools they can use. Sign up your non-programmer friends and relations for his survey at http://www.cs.cmu.edu/~NatProg

Dave Maulsby works with PBE, modeling of users activities. He is working on a tool for individual investors to program Web agents to retrieve the information they need.

Allen Cypher wrote the book on Programming By Demonstration, or at least edited it: his Watch What I Do [2] is the classic of the field. His Cocoa (formerly KidSim) lets kids create their own programs with graphical rewrite rules (similar to Agentsheets Visual Agen Talk.) The children at CHI Kids this year used this tool to program simulated characters in virtual worlds.

Richard McDaniel of CMU is programming Gamut, a video and board games (2D) building environment. His goal is to see how much you can do without editing. He has TIC-TAC-TOE implemented, and hopes to create Monopoly.

George Strohofer isn't directly involved; he is here for others at Boeing Aircraft who use macros in Microsoft desktop applications (Access and Excel), and Visual Basic for analysis.

Dorothy Lieffers creates Decision Support software for administrators using Visual Basic and wizards. Her end-users are executives and managers.

"What Do We Do About It?"

The major remaining activity in the SIG was collecting ideas for encouraging the use of End-User programming: primarily a Web page and mailing lists for End-User Programming, both of which have since been created (thanks to the University of Massachusetts at Lowell for hosting them.)

Ideas for Web Page

http://www.cs.uml.edu/~hgoodell/EndUser

1. Contact info. for people involved with end-user programming, stating what tools they are using.

2. Links to related sites such as newsgroups for visual programmers.

3. Create a FAQ for newcomers.

4. Indicate/Decide what types of people are we trying to help.

5. Provide a forum to discuss basic issues.

6. Organize the page by domain: "Who has what for my domain".

7. Provide a set of target challenges/benchmarks -- define examples (see Watch What I Do [2] appendix.)

8. User experiences -- studies -- raw data.

Mailing Lists

1. Make separate lists for developers and users, because their needs and interests are quite different.

About the Authors

Howie Goodell has been programming industrial equipment and instrumentation since 1979. He holds a BS and MS in Analytical Chemistry from Northeastern University, and is currently taking doctoral qualifying examinations in Computer Science at the University of Massachusetts at Lowell.

Howie is interested in techniques that reduce the artificial complexity of programming complex industrial equipment; so the experts who understand the machines' operation can program them directly.

Carol Traynor is a doctoral candidate in the Computer Science Department at the University of Massachusetts Lowell. She holds an MS (Computer Science) from the University of Massachusetts Lowell, and a BA (Math, French) and H.Dip.Ed from the National University of Ireland.

Her research focuses on an investigation of design techniques for building user-interfaces of complex systems for non-technical computer users. Participatory design techniques are used to bring end users into the design process. She is currently designing a PBD language for GIS to enable non-technical end users to exercise the capabilities of a GIS without having to learn the technical concepts embedded in most traditional GIS interfaces.

Author's Addresses

Howie Goodell
Tokyo Electron Massachusetts
123 Brimbal Ave.
Beverly, MA 01915 USA
email: hgoodell@tem.teainet.com
Tel: +1-508-921-0031

Carol Traynor
Department of Computer Science
University of Massachusetts Lowell
One University Avenue
Lowell, MA 01854 USA
email: ctraynor@cs.uml.edu
Tel: +1 508 934-3385

References:

1. Nardi, Bonnie A., A Small Matter Of Programming, Perspectives on End User Computing. MIT Press, Cambridge MA, 1993.

2. Cypher, Allen. Watch What I Do, Programming by Demonstration. MIT Press, Cambridge MA, 1993.

No earlier issue with same topic
Issue
Previous article
Article
SIGCHI Bulletin
Vol.29 No.4, October 1997
Next article
Article
No later issue with same topic
Issue

 

Powered by Plone CMS, the Open Source Content Management System

This site conforms to the following standards: