IBM RealThings are a major step forward in user
interface design,
with a goal of making computing more approachable for novice and casual users. We intend that this user interface style, which resembles real-world counterparts, be productive, visually compelling, and fun to use.

This notebook has four sections:

Premises
As we experimented with the RealThings UI design, we evaluated several premises through prototyping and user testing.
Examples
The RealThings are not products, but designs providing a practical and useful level of function. These examples are available 'as is' for the purpose of stimulating discussion and evaluating an alternative to the current graphical user interface style.
Guidelines
Learn what you need to know to create RealThings. These guidelines are built upon a foundation provided by the HCI user interface design principles.
Insights
Contains a RealThings White Paper, written by Justin Richards, which introduces the motivation for exploring an interface resembling real-world objects.

For more information:
If you prefer, try the outline view (no frames) or the printall view [490KB] (entire set of pages in one file). IBM RealThing Guidelines: Focus premise


Focus

Today's computer-based user interface mechanisms can be removed and replaced by more natural and intuitive ones allowing designers and users to focus on information content.

A typical word processor can consume up to 30% of the display with title bars, menu bars, tool bars, and status lines. Even though the RealThings we've developed so far don't match a word processor's high level of function, we do believe that multiple design strategies can give most of the space back to the user while simplifying user interaction at the same time.

RealBook exampleFor example, the RealBookTM removes the typical GUI visual clutter providing more space for content and more intuitive interactions for the user. The natural use of covers, tabs, and pages enables the user to focus on the task.
IBM RealThing Guidelines: Transition premise


Transition

Simulation of real-world interaction mechanisms can provide a bridge into the computer realm for new and novice users. Some techniques may even be applicable for more advanced users, especially when the techniques are so familiar they are essentially transparent to the task.

RealPhone with the handset off-hookFor example, the RealPhoneTM provides a handset similar to those in the real world. Clicking the handset causes it to come off-hook answering the phone or placing a call. Obviously, a handset isn't necessary on a computer-based phone - most computer phones simply use a push button labeled Dial. However, we found that many users intuitively understand the role of the handset without needing any instructions or labels. The RealPhone also provides an animated, slideout drawer containing speed-dial numbers and other settings. Tests have shown that users enjoy the interaction and appreciate the reduced clutter.

IBM RealThing Guidelines: Value-add premise


Value-add

Using real-world objects as a starting point, we can add significant value over real-world objects and mechanisms through the use of the computer in a complimentary manner.

Entering alphanumeric phone numberThe current implementation of the RealPhone was designed primarily to explore the Focus and Transition premises; however, it does enhance the real-world phone by allowing the user to dial an alphanumeric phone number. The user simply types the characters, such as 1-800-CALLIBM. While this is just one minor enhancement, imagine what might be accomplished with further analysis and design.

For example, the myriad of options available on telephones today, such as call waiting, call forwarding, caller-id, caller-id blocking, and many more, have created a user model so complicated that most people don't even know there are exclusive interactions between these functions - some must be cancelled in order to enable others. The interaction using today's real-world telephone requires dialing a series of *nn codes such as dialing *70 to cancel call waiting. This is an area of great opportunity for telephone implementations on the computer. An implementation such as the RealPhone, extended to provide this added value, might even be a model on which future real-world (computerized) telephones could be designed.

Strictly emulating the real-world may not be the best answer for all kinds of objects and all tasks. While it may intrigue and delight new users, and entice them to delve deeper in exploration, the real-world imposes limits of its own - limits that we can surpass by using computers.

IBM RealThing Guidelines: Presentation premise


Presentation

A realistic design for high-function applications may require a combination of presentations ranging from realistic for common and simple tasks to abstract for complex ones.

Some tasks are by nature abstract and have no obvious real-world representation. It is our expectation that some of the interaction mechanisms developed for RealThings will be appropriate and useful even for these tasks.

One approach to addressing a spectrum of objects, task requirements, and users is to base implementations on a model-view paradigm. The model-view paradigm separates object semantics, what an object does, from its view, which establishes how the user interacts with it. In fact, we have experimented with extending this paradigm to model-view-presentation, which makes a further distinction between the abstract definition of the view and its actual rendering.

Both approaches allow developers to create objects that can present different appearances and interaction techniques to users. This means each user can have an interface style that is appropriate, and that they are most comfortable using, in the current situation. The RealCDsTM shown below present three different presentation styles.

3 different views of RealCD

We are also designing programming frameworks that make it easy and productive for developers to provide multiple presentation and interaction styles for an object. This approach will allow third parties to provide alternative styles, giving more choices to users - similar to the multiple screen savers and color-scheme options offered today.

IBM Real Thing Guidelines: RealPhone


RealPhone

Link to the RealPhone demo done in Shockwave The RealPhone is a speaker-phone that supports dialing and answering, a name/number list, 10 speed dial buttons, flash, mute, and redial. You can use either a mouse or the keyboard for all interactions. It is implemented using the non-rectangular window capability of Windows 95. It can be used on systems having an IBM MWave digital signal processor, such as several models of the IBM ThinkPad and Aptiva product lines, or any system using the IBM Multimedia Modem adapter card.

The RealPhone was the first RealThing we designed, and much of what we learned was incorporated into the RealCD and the RealThings Guidelines. We have not revisited the RealPhone to include aspects of the guidelines that were added later.

IBM Real Thing Guidelines: RealCD


RealCD

RealCD example The RealCD plays audio CD's. Its interface resembles a plastic CD jewel case with a control panel for the basic playing functions. The case can be opened to display the CD booklet and playlist. Several pictures are included for the case and booklet covers; however, users can also incorporate their own scanned or drawn pictures. Users enter the CD title and playlist (track titles). These customizations appear whenever the CD is played. In addition, users can set the CD to automatically start playing when inserted by selecting the AutoStart option during installation.

The RealCD is implemented in Java and is available as an application.

IBM Real Thing Guidelines


RealBook

RealBook example

The RealBook is an information container that simulates the operation of a book. The book is implemented in Java and can be populated with three categories of content: covers, tabbed separators, and documents. Documents can contain HTML or Java AWT components, and the content can flow across several pages within a tabbed section.

Single and facing page views, as well as left to right and top to bottom orientations are also supported. A simple Java interface enables developers to include information in the book. This interface is still in development. To see an example of the book, check out the booklet in the RealCD.

IBM Real Thing Guidelines: Disclosure

clear space
Disclosure
Disclose discrete levels of function incrementally

Economic use of screen space along with incremental introduction of function are two complementary features demonstrated by RealThings. The use of real-world metaphors might lead you to believe that RealThings would be wasteful of valuable screen space. After all, real-world objects are often encased in lots of plastic, steel, or wood that has no function other than physically containing the object's "contents".

In the computer interface our goal is to make each object immediately recognizable by the user. This can be achieved through shape recognition and the use of other visual cues. But we don't need to keep the recognizable version of the object around all of the time. Similarly, the user probably doesn't always need the full-function of an object at their fingertips. Each RealThing provides a sequence of views that use screen space judiciously and present function in logical increments.

Object views
In the RealThings implemented so far, we have identified four levels of object views:

Each RealThing should provide several of these views but may not need to provide all of them.

Minimal view
minimal view of RealCD controlsThe minimal view provides the most basic level of function and doesn't necessarily resemble the object's real world counterpart. The minimal view of the RealCD consists of only the playing controls (due to Java implications, this view is not in the first release). The RealPhone does not provide a minimal view.

Base view
RealPhone base viewThe base view provides a basic level of function in a form that's immediately recognizable by the user. The base view of the RealCD shows the playing controls on the edge of a CD jewel case, which identifies the CD. The RealPhone's base view looks like a real-world telephone. It provides ten speed-dial buttons, a volume control, a functional handset, and a rocker switch that toggles to the full-function view.

Full-function view
The full-function view expands on the base view by adding extra function that may be used less frequently. The full-function view of the RealCD shows an open jewel case that lists the CD tracks. It also makes the CD booklet available. The RealPhone's full-function view, as shown below, adds a numeric pad and buttons for Flash, Mute, and Redial.
clear space

RealPhone full-function view

Ancillary views
The ancillary views show aspects of the object that may be used occasionally, such as configuration settings and instructions for use. The RealPhone provides an animated slideout tray that contains a notebook. The notebook contains a phone number list, fields for adding new names and numbers, and buttons for dialing a number from the list or assigning a phone number to a speed dial button.
clear space

RealPhone ancillary view

Component Device Model
The Component Device Model is a general model that defines a base view, full-function view, slideout tray, and tabbed notebook. It is applicable for implementing a variety of device objects, such as telephones, fax machines, and printers. The RealPhone is an implementation of this model. It's an ideal candidate for implementation as a programming framework. We haven't gotten to that task yet, but if you want to give it a try we would love to talk with you.

IBM Real Thing Guidelines: Position


Position
Keep primary controls in the same position as the user switches between views

RealCD controls map from base view to full function viewWhen multiple views of an object are provided, as described in the guideline on Incremental and Discrete Function Disclosure, keep the primary controls in the same position on the screen as the user switches between the views. For example, the RealCD provides a base function view and a full-function view. The player controls remain in the same position as the user switches between the two views.

Also, make it easy for the user to move a view back onto the screen if a portion of it appears off of the screen. If the RealCD’s base function view is positioned on the left side of the screen a portion of the full-function view may appear off of the screen. However, the user can easily drag the view back onto the screen. Do not move the view in an attempt to keep it on the screen. Moving the view would cause the controls to move, making it more difficult for the user to work with the object.

IBM Real Thing Guidelines: Value-add


Value-add
Provide some value-add over real-world counterparts

The initial value of RealThings lies in ease of use resulting from recognition and intuitive operation. But in many cases the computer should allow us to do things better than we can in the real world. Look for opportunities to provide additional value. Provide some function that isn't possible or practical in real world counterparts.

Entering alphanumeric phone number For example, the RealPhone allows users to dial alphanumeric phone numbers like 1-800-CALL IBM by typing the letters. The user doesn't have to convert the letters to the proper digits on the number pad. This is a simple example and much more powerful assistance should be practical.

When providing value-add over the real-world make sure that the user's model is in no way distorted or, worse still, broken.

IBM Real Thing Guidelines: Shortcut



Shortcut
Anticipate and assist frequently occurring tasks

Alt keyProvide shortcuts for tasks that users do frequently. For example, the RealPhone makes it very easy for the user to answer when the phone rings, regardless of what the user is doing at the time. When the phone detects an incoming call it becomes the topmost window, but it doesn't take the keyboard focus. The user can keep on working in their current application, or decide to answer to the phone. To answer the phone all the user has to do is give the RealPhone focus. In Windows 95 you can give an object the focus by clicking on it, by using Alt+Tab, or by using a shortcut key. The phone is designed such that when it receives the focus while detecting an incoming call it automatically answers.

IBM Real Thing Guidelines: Animation


Animation
Use animation to convey relationships

Many people are captivated by animation effects, especially in today's relatively static interfaces. But animation has a important functional role as well. It provides a way of showing relationships between components, such as the tray that slides out from the RealPhone.

RealPhone tray - animated
RealPhone tray - animated

The relationship between the tray and the phone is unambiguous. It's clear that the tray is contained within the phone. It doesn't just suddenly appear and does not exist independent of the phone.

It's important not to over use animation. Too many animations at the same time or an animation that continues on longer than useful becomes an annoyance.

IBM Real Thing Guidelines: Sound


Sound
Use sound to provide cues and feedback, and to create the desired ambiance

Ringing phoneThe real world is full of sounds that create ambiance and provide us with cues and feedback. RealThings should provide user options for sound support, including the ability to turn sounds off, and select levels of sound support. Sounds should be consistent with their real-world equivalents to ensure that they correspond to the user's expectations.

We suggest separating sounds into three types: background or ambiance creating sounds, such as a ticking sound for a clock; normal function sounds, such as a click when a button is pushed; and alarm sounds when events occur that require the user's attention, such as a cuckoo sound for a clock, or a bell for a ringing telephone.

IBM Real Thing Guidelines: 3D model


3D model
Generate images from 3D models to provide a compelling visual experience

3D view of RealPhone RealThings are created for today's two-and-a-half dimension desktops but to achieve realism we use bitmap images generated from 3D models. Three-dimensional modeling tools typically provide the ability to control camera orientation, to capture bitmaps from different angles, and can provide impressive lighting effects with reflections and shading accurately rendered. The best part is that rendering isn't real-time, it's done during development so you can spend as much time as you want creating a truly compelling image.

The bitmaps should be taken with a camera nearly perpendicular to the surface you want to render so that controls such as buttons, sliders, and entry fields will look natural when mapped onto the surfaces. For the RealPhone we used an angle of about ten degrees so the user can clearly see the edges of the tray that slides out from the front of the phone.

As processor speed and our ability to render 3D objects in real time increases we will be able to render the 3D models in real-time and permit alternate viewing points.

IBM Real Thing Guidelines: Shape


Shape
Use naturally occurring shapes for RealThings to aid recognition by users

RealPhone Use non-rectangular windows when the user environment supports them. In Windows 95 a window's shape can be defined by the use of a non-rectangular region. Use of non-rectangular windows can significantly enhance the real-world effect of RealThings. It can also provide better screen space utilization. The RealPhone uses a non-rectangular window.

cone, cube, sphere When non-rectangular windows are not supported use transparency to create the same visual effect. Objects will appear more natural and can be more quickly identified when they have characteristic shapes that are easily recognized.

IBM Real Thing Guidelines: Control


Controls
Adopt standard UI controls and use them consistently

We recommend the use of several standard user interface elements and techniques. This will not only make objects more recognizable by users, it will allow developers to build RealThings from standardized toolkits. Some of the elements we recommend you standardize are:

We have identified standard classes of control elements for activators and selectors.

RealPhone speed dial buttonsActivators simply cause an action to happen and have no persistent state. They are typically presented as buttons, such as the speed-dial buttons shown on the Realphone to the right.

RealPhone toggle switchSelectors allow the user to pick one or more choices from a set of choices. They are typically presented as switches, dials, sliders, and lists. The RealPhone uses a 1-of-2 selector in the form of a rocker switch to switch between base and full-function views.

These controls should look real and natural, and not be the standard controls provided by current GUI toolkits.

By using a model-view-presentation paradigm in the implementation of these controls the developer can create an appearance that is most appropriate for the real thing being created without having to modify the program's logic, which is encapsulated in the model. Even more interesting, the developer might make several visual styles available for users to choose from.

IBM Real Thing Guidelines: Affordance

clear space
Affordance
Use natural and intuitive affordances

hand grip imageProvide natural affordances as interaction mechanisms wherever possible. Handles and other grasping surfaces provide immediate visual cues that most users will recognize. Keep the interactions simple, such as a single mouse click, and avoid real world controls that are difficult to emulate using the input devices provided. For example, rotating controls such as knobs and dials are difficult to map to the x/y movement of a pointing device such as a mouse.

RealPhone tray affordanceThe Realphone uses a thumb indentation and arrows to indicate the tray handle. A simple click on the handle slides the tray out providing accesses to the notebook.

IBM Real Thing Guidelines: Pointer


Pointer
Avoid changing the pointer, except to indicate the current tool

coloring toolUse pointer changes sparingly. A constantly changing pointer is distracting and may actually interfere with explicit pointer changes caused by the user. Pointer-based tools, such as found in many drawing programs, are a good way to provide a large number of different functions to the user. The trend is to provide common functions that can be applied across a variety of objects, such as a coloring tool that might be used to color text, bar graphs, buttons, or most any aspect of the interface. If an individual object changes the pointer it may be taking control away from the user and interfering with the user's intent.

IBM Real Thing Guidelines: Assistance


Assistance
Provide multiple levels of user assistance

hover helpProvide several levels of assistance appropriate to the complexity of the object. Simple cues and reminders can be provided through hover help balloons that appear near the pointer when it pauses over a control for a brief period. The RealPhone uses hover help to identify the function of the control and to tell the user the keyboard equivalent. A pointer-based Help tool can also be used to provide this first level of assistance.

An approach resembling cue cards can be provided for the next level of explanation which should address the role of the control or object in accomplishing tasks.

Cue cards can be extendable to address to the third level which is how to information. This information should provide step-by-step instructions for a typical case along with an example.

The highest level of assistance is conceptual. Here you should provide an overview of the object's role, functions, and relationships with other objects. A section in the object's Properties Notebook is an appropriate place for this material.

Provide hints and tips to help users achieve efficient and productive usage quickly. The Properties Notebook is a good place to provide this material also. The contents of Properties Notebooks should also be presented in real-world form, not in traditional GUI form.

From each level of assistance, getting to the next level should be obvious and easy. For example, the cue card might have a button that expands it to include how-to information, and another button that displays the Properties Notebook opened to the concepts section.

IBM Real Thing Guidelines: Interaction


Interaction
Make interactions feel real

Visuals
RealThings should look real all of the time, even while being moved and sized. If you use Microsoft's PlusTM for Windows 95 the RealPhone is fully rendered while it is being moved on the desktop. Likewise, it is fully rendered as it is being sized and we preserve its aspect ratio as shown below.

Small, medium, large RealPhones with aspect ratio maintained

This eliminates any trial-and-error guesswork on the part of the user. They can see exactly what they're getting, how big the controls are and how readable the labels are at every instant.

Because the other RealThings are written in Java, we wrote our own window class that does real-time moving and sizing in Java.

Interaction
To move a RealThing, press, hold, drag, and release with mouse button 1 while pointing at any area that is not interactive. For example, you can move the RealPhone by pointing anywhere on the case. The handset, speed-dial buttons, rocker switch, and volume control each do something else so you can't move the phone by pointing at them.

Move pointer As soon as a move operation is detected, we change the pointer to a four-pointed arrow to tell the user they're moving and not performing some other function. Move is detected when the button is pressed and the pointer has moved a small amount.

Size pointerTo size a RealThing, press, hold, drag, and release with mouse button 1 while pointing anywhere along the outer-edge of the visual image. Because there are no visible borders like today's GUI windows, we change the pointer to a two-ended arrow when it's over the edge. The pointer remains a two-ended arrow while the user is sizing.

The most important thing to remember about sizing RealThings is that they remain fully functional regardless of their size. The RealPhone still works no matter how small you make it, and you can make it about the same size as a Windows 95 icon!

When the visual controls become too small to use, and that's a different size for each user, keyboard techniques can be used instead. There's little need to have a non-interactive minimized window when using RealThings. A minimal function view can take the place of a minimized window.

IBM Real Thing Guidelines: Coexist


Coexist
Coexist with other desktop applications where it benefits the user

RealThings run on existing desktops along with native applications. For the most part they use replacement approaches for traditional window borders, titles, borders, and menu bars. But users might expect them to behave in some ways like other applications. Popup menu for RealPhoneFor example, Windows 95 applications provide a pop-up menu. For the RealPhone we chose to provide a pop-up menu to support moving and sizing using the keyboard, and for Close. We also added a Always on Top choice, and supported minimize for users who want to use the Windows 95 Task Bar. We considered using a visual control for Close, something like a power switch, but we decided to use the standard desktop pop-menu in this case.

The remaining RealThings are written in Java so we decided to avoid using platform specific interfaces. Some interfaces, like cut and paste and drag/drop, are fairly common across platforms and should be considered so that RealThings can interact in useful ways with other objects. We plan to explore drag/drop between RealThings and between RealThings and other objects in the future.

RealThings Introduction - Today's GUI - The 'WIMP' Interface


White Paper
Evolution and Revolution in the User Interface
by Justin Richards

Today's GUI - The 'WIMP' Interface
The user interfaces of today are dominated by the so-called WIMP UI - Windows, Icons, Menus, Pointers. While there is no denying the success of these interfaces in bringing desktop computing to millions of users across the world, the GUI has grown to be a cluttered, discordant world of clashing icons and wasted screen space.

In the WIMP world, objects (or more usually, applications) are presented in rectangular windows. They do not look real, or even bear more than an occasional passing resemblance to anything in our real world outside the computer. And amongst the visual noise and clutter, are hidden the clues necessary to make the cognitive leap to accommodate a metaphor which relies on the idea that 'windows' can exist on a 'desktop.'

Objects and applications alike are represented by icons. But these icons only show a gross level of information - they indicate the class of object, but rarely impart status information or make important properties apparent. All icons are the same relative size, and pretty much the same shape. And icons must be 'opened' before they are 'alive' enough to do very much.

In the WIMP world, menu bars and tool bars proliferate. Users spend much of their time 'mining' menus or hovering over buttons waiting for help.
example of nested menus

As the user fumbles through the interface in search of particular functions, the clutter and visual pollution detracts from the content or task which should be the user's main concern. The UI itself distracts and intimidates the user rather than helping.

Today, the focus of the user interface is often on the GUI controls.

An Alternative - A Clean Screen UI and RealThings
In many respects, the way forward for today's content-centric world is obvious. Cut down on the visual clutter and pollution and focus instead on the content. This will have the bonus effect of making that content seem more like 'real world' content as traditional design methodologies
example of organizer drawerand experience can be brought to bear. An escape from the constraints of the rectangular world of the WIMP interface can only bring the UI closer to the world that the user already knows and understands.

In fact, we can already see the start of a reaction against the cluttered WIMP world. Lotus SmartSuite, for example, provided tool bars according to context, rather than present every conceivable function for every possible circumstance.

More interesting is the UI demonstrated by Lotus Organizer, where most operations can be performed in place without resorting to menus or tool bars. Users are presented with a UI that resembles something they already understand - a book. The Smart Center drawers for Calendar (shown here) and Address are also a natural and very usable extension of this philosophy. They are unobtrusive yet accessible - combining the value of pull-down menus with real objects that provide valuable, but not over-comprehensive, function for standard and frequent tasks to the user.

The World Wide Web
If 'suite-bloat' is one driver towards a clearer, more accessible world for the users, the World Wide Web is another. The Web is content-based, and that content assumes only the relatively limited built-in function of a Browser. Any other functionality has to be provided intrinsic to the content. Often this function takes the form of pseudo-menus and pick-lists, but even these exhibit a freedom and a freshness of design. This is partly because of the fact that the content is freed from the software and mental constraints of the standard UI tools and widgets provided by the underlying platform.

It is also partly due to the democratization of content. The pages of content on the Web are often put together by designers and novices with little or no previous computer design or programming experience. But, in fact, these are people who are psychologically more able to communicate with the 'common user'. Their designs are not polluted by the design constraints that the UI designer used to have to deal with.

The most interesting design emerging from the Web, though, is where function is intrinsic to content - where objects (for want of a better term) exhibit exactly the behavior that their visual appearance suggests; where function is in support of task; where form suggests purpose; where interaction is apparent from visual appearance.

Web to WIMPs
It is hardly surprising that there is a general move to incorporate web-like interfaces in the WIMP world. But generally, this is a patchy solution that combines two fundamentally incompatible styles of UI.

RealThings: Focus on content, not control
While the general movement is in the right direction, the progression is still quite slow. We can take these notions further still, and the key to this is IBM RealThings.

RealThings exhibit a new, real-world user interface style. They set a new direction in making user interfaces more approachable for novice and casual users. At its simplest, the RealThings philosophy is to make software constructs and applications appear as they would if they existed in the real world outside the computer. Objects and mechanisms are presented in context, and actions are surfaced in more natural ways.

The key to making RealThings work as the next major stage in the development of ease of use is knowledge transfer from the real world. Computer users, no matter how new to the interface, no matter how naive, possess a huge body of experience from, and a good understanding of, the real world. By making the behavior of computer objects more natural - more like the user expects from his or her experience of the world - we make it more accessible, less daunting, easier to comprehend and to use. In short, rather than expecting the user to learn what is in effect a new language, we leverage what the user already knows.

And in doing so, we shift the focus away from controls and back on to content.

RealThings
As we have said, the primary motivation for making objects seem more 'real' is to capitalize on what the user already knows and leverage knowledge transfer from the real world. It is not to slavishly copy objects, techniques and interactions from the real world. One example of a RealThing we have created is the IBM RealPhone.

RealPhone example

RealBook example Currently in development is the RealBook. Here is an object which will be integral to the user's computer experience - not peripheral and related to just a small subset of tasks. And we are capitalizing on the user's knowledge of real books as well as a design that is well-understood and tested by time.

But we aren't just copying the real-world with its inherent limitations, we are providing navigation techniques that enhance the real world, as well as providing mechanisms and interaction cues that are immediately recognizable and understood.

RealCD example The RealCD will soon be available as another RealThing. In the real world, the user has to take the CD to a player (connected to an amp, speakers, etc), insert it, and only then can they play the CD. Using the RealCD this problem is addressed by bundling the player and the content together - a solution that is impractical in the real world but which addresses the user's actual task.

Having decided to bundle the two, though, the designers have made the CD look like what users could reasonably expect an amalgam of CD and Player to look like if it did exist in the real world. The object itself - the composite - is not 'real' but its components are. The CD case looks like a real CD case and provides the visual information about medium and content that is important in the real world. The controls look like the control panel of a CD Player. Given that users have an understanding of the task involved and have knowledge of how that task is performed in the real world, of the objects with which they would interact, this design is easily accessible.

Justin Richards

About the Author

The following are some of the folks that have participated in RealThings design projects:

Concept & Direction Dick Berry, Roland Merrick
Executive Producer Tony Temple
Producer Paul Waldo
Programming Scott Morgan, Craig Swearingen
Usability Scott Isensee, Greg Lubel, Shirley Martin
User Interface Design John Mullaly, Dave Roberts, Andy Smith
Visual Design Didier Bardon, Martin Morgan
Web Design Denise Burton, Mark Evans, Valerie Fox, Trish Kerr, Linda Lisle, Nick Loat