Although mobile, tablet, large display, and tabletop computers increasingly present opportunities for using pen, finger, and wand gestures in user interfaces, implementing gesture recognition largely has been the privilege of pattern matching experts, not user interface prototypers. Although some user interface libraries and toolkits offer gesture recognizers, such infrastructure is often unavailable in design-oriented environments like Flash, scripting environments like JavaScript, or brand new off-desktop prototyping environments. To enable novice programmers to incorporate gestures into their UI prototypes, we present a "$1 recognizer" that is easy, cheap, and usable almost anywhere in about 100 lines of code. In a study comparing our $1 recognizer, Dynamic Time Warping, and the Rubine classifier on user-supplied gestures, we found that $1 obtains over 97% accuracy with only 1 loaded template and 99% accuracy with 3+ loaded templates. These results were nearly identical to DTW and superior to Rubine. In addition, we found that medium-speed gestures, in which users balanced speed and accuracy, were recognized better than slow or fast gestures for all three recognizers. We also discuss the effect that the number of templates or training examples has on recognition, the score falloff along recognizers' N-best lists, and results for individual gestures. We include detailed pseudocode of the $1 recognizer to aid development, inspection, extension, and testing.

https://faculty.washington.edu/wobbrock/pubs/uist-07.01.pdf

Gestures without libraries, toolkits or training: a $1 recognizer for user interface prototypes

A user interface software tool helps developers design and implement the user interface. Research on past tools has had enormous impact on today's developers—virtually all applications today are built using some form of user interface tool. In this article, we consider cases of both success and failure in past user interface tools. From these cases we extract a set of themes which can serve as lessons for future work. Using these themes, past tools can be characterized by what aspects of the user interface they addressed, their threshold and ceiling, what path of least resistance they offer, how predictable they are to use, and whether they addressed a target that became irrelevant. We believe the lessons of these past themes are particularly important now, because increasingly rapid technological changes are likely to significantly change user interfaces. We are at the dawn of an era where user interfaces are about to break out of the “desktop” box where they have been stuck for the past 15 years. The next millenium will open with an increasing diversity of user interface on an increasing diversity of computerized devices. These devices include hand-held personal digital assistants (PDAs), cell phones, pages, computerized pens, computerized notepads, and various kinds of desk and wall size-computers, as well as devices in everyday objects (such as mounted on refridgerators, or even embedded in truck tires). The increased connectivity of computers, initially evidenced by the World Wide Web, but spreading also with technologies such as personal-area networks, will also have a profound effect on the user interface to computers. Another important force will be recognition-based user interfaces, especially speech, and camera-based vision systems. Other changes we see are an increasing need for 3D and end-user customization, programming, and scripting. All of these changes will require significant support from the underlying user interface sofware tools.

/pdf/past-present-and-future-of-user-interface-software-tools-4tyf5iisz8.pdf

Past, present, and future of user interface software tools

This article summarizes the historical development of major advances in humancomputer interaction technology, emphasizing the pivotal role of university research in the advancement of the field.

/pdf/a-brief-history-of-human-computer-interaction-technology-2qibkiiik0.pdf

A brief history of human-computer interaction technology

This is an excerpt of a much longer work: Brad Myers, Scott E. Hudson, and Randy Pausch, “Past, Present and Future of User Interface Software. Tools,” ACM Transactions on Computer Human Interaction, To appear in the Special Millennium Issue, 2000.

Past, Present and Future of User Interface Software Tools

The Amulet user interface development environment makes it easier for programmers to create highly interactive, graphical user interface software for Unix, Windows and the Macintosh. Amulet uses new models for objects, constraints, animation, input, output, commands, and undo. The object system is a prototype instance model in which there is no distinction between classes and instances or between methods and data. The constraint system allows any value of any object to be computed by arbitrary code and supports multiple constraint solvers. Animations can be attached to existing objects with a single line of code. Input from the user is handled by "interactor" objects which support reuse of behavior objects. The output model provides a declarative definition of the graphics and supports automatic refresh. Command objects encapsulate all of the information needed about operations, including support for various ways to undo them. A key feature of the Amulet design is that all graphical objects and behaviors of those objects are explicitly represented at run time, so the system can provide a number of high level built-in functions, including automatic display and editing of objects, and external analysis and control of interfaces. Amulet integrates these capabilities in a flexible and effective manner.

/pdf/the-amulet-environment-new-models-for-effective-user-4v0mxdya8r.pdf

The Amulet environment: new models for effective user interface software development

Adding animation to interfaces is a very difficult task withtoday’s toolkits, even though there are many situations inwhich it would be useful and effective. The Amulet toolkitcontains a new form of animation constraint that allowsanimations to be added to interfaces extremely easily with-out changing the logic of the application or the graphicalobjects themselves. An animation constraint detectschanges to the value of the slot to which it is attached, andcauses the slot to instead take on a series of values interpo-lated between the original and new values. The advantageover previous approaches is that animation constraintsprovide significantly better modularity and reuse. Theprogrammer has independent control over the graphics tobe animated, the start and end values of the animation, thepath through value space, and the timing of the animation.Animations can be attached to any object, even existingwidgets from the toolkit, and any type of value can beanimated: scalars, coordinates, fonts, colors, line widths,point lists (for polygons), booleans (for visibility), etc. Alibrary of useful animation constraints is provided in thetoolkit, including support for exaggerated, cartoon-styleeffects such as slow-in-slow-out, anticipation, and follow-through. Because animations can be added to an existingapplication with only a single extra line of code, we expectthat this new mechanism will make it easy for researchersand developers to investigate the use of animations in awide variety of applications.Keywords: Animation, Constraints, Toolkits, User Inter-face Development Environments, Amulet.To appear in UIST’96: ACM Symposium onUser Interface Software and Technology, Nov.6-8, 1996. Seattle, WAINTRODUCTIONBy providing better modularity for the software for userinterfaces, the Amulet toolkit [8] achieves increased reuseand decreased code size, and makes it easier for research-ers and developers to create applications. For example, inAmulet, the interactive behavior of objects can be definedentirely independently from their graphical look by attach-ing “Interactor” objects to the graphics. Command obje cts[9] encapsulate the complete information about operations,and can be hierarchically linked so each application layercan be separately defined. We have followed this philoso-phy in our new support for animations and other time-based behaviors. The goal is to make simple animationsextremely easy to add to an interface, and still supportcomplex animations. This is achieved by allowing theanimations to be defined independently from the actionsthat start the animation and the graphics that are ani-mated. Furthermore, the animation itself is modularized:the start and end values of the animation, the path throughthe value space, and the timing of the animation can all beindependently specified.We are able to provide this new level of modularity by us-ing the flexible Amulet constraint system. If an animationconstraint is attached to a slot (instance variable) of anobject, then changes to that slot trigger the animation,causing the slot’s value to change smoothly from its old toits new value. For example, if a slot contains 10 and is setto be 100, an animation constraint might immediatelyoverride the value and set the slot with 11, and then set theslot with a series of values up to 100 over a period of twoseconds. Since there are a wide variety of parameterizedanimation constraints provided in the library, an anima-tion can be added to an existing interface with a single lineof code. All the messy details of timing, redrawing, set-upand clean-up of animations, and interactions with otherparts of the system, are automatically handled by the ani-mation constraint mechanism.We are particularly interested in the use of animations toenhance interaction in regular user interfaces. Althoughanimations are widely used in games and specializedvisualization software ([10] has a survey), their use in con-ventional interfaces is limited to a few predefined cases,

Easily adding animations to interfaces using constraints

The Amulet User Interface Development Environment contains a comprehensive set of tools that make it significantly easier to design and implement highly interactive, graphical, direct manipulation user interfaces. Applications implemented in Amulet will run without modification on Unix, PC, and Macintosh platforms. Amulet provides a high level of support, while still being Look-and-Feel independent and providing applications with tremendous flexibility. Amulet currently provides a low-level toolkit layer, which is an object-oriented, constraint-based graphical system that allows properties of graphical objects to be specified in a simple, declarative manner, and then maintained automatically by the system. The dynamic, interactive behavior of the objects can be specified separately by attaching high-level "interactor" objects to the graphics. Higher-level tools, such as the Gilt interface builder, allow parts of the user interface to be layed out without programming. The Amulet toolkit is available for unlimited distribution by anonymous FTP or WWW. Amulet uses X/11 on Unixbased systems, the native Windows NT or Windows 95 toolkit on PCs, and standard Quickdraw on the Macintosh. This document contains an overview of Amulet with download and installation instructions, a tutorial, and a full set of reference manuals for the Amulet system.

/pdf/the-amulet-v3-0-reference-manual-4ra7cmrrny.pdf

The Amulet V3.0 Reference Manual

Although interactive, direct manipulation applications are known to be difficult to design and implement, the toolkits with which they are built generally do not contain any particular support for debugging. The Amulet toolkit contains a comprehensive collection of monitoring and debugging tools, including an interactive ‘‘Inspector.’’ These tools are provided in a machine-independent way in C++ without using hooks into the compiler, symbol tables or the runtime stack. Some of these capabilities are based on wellknown techniques, but others are innovations that have never been provided before. Based on our experience with writing and debugging interactive applications, we have provided tools to address the most common and difficult programming bugs. The capabilities include: viewing values of objects as they change; breaking into the debugger when values change; viewing the inheritance and grouping hierarchies of objects; feedback for why objects are not visible or not interactive; tracing of constraint dependencies; and various techniques to search for objects. In addition, programmers can edit the values displayed in the Inspector, supporting rapid prototyping without requiring a C++ interpreter. These features make debugging interactive applications written using Amulet is substantially easier than with other toolkits.

Debugging Interactive Applications

Brad A. Myers,Rich McDaniel, Alan Ferrency, Rob Miller, Patrick DoaneJanuary 1996Human Computer Interaction InstituteSchool of Computer ScienceCarnegie Mellon UniversityPittsburgh, PA 15213(412) 268-5150bam@cs.cmu.eduhttp://www.cs.cmu.edu/~amuletAbstractAmulet is a new user interface software environment for C++ on X/11, MicrosoftWindows NT or 95, and the Macintosh, which facilitates user interface research by beingvery open and flexible. In particular, new constraint and undo algorithms can be added,the widgets can modified and replaced, and support is provided for building high-leveltools.Keywords: UI ToolkitAttending Workshop: Brad A. Myers

Overview of the Amulet User Interface Toolkit

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Alan Ferrency

Author Tools

Chat about Author