Browse Prior Art Database

Autogenerating Scripts, Shortcuts, and Wizards Based on Human Interaction

IP.com Disclosure Number: IPCOM000038304D
Original Publication Date: 2005-Jan-31
Included in the Prior Art Database: 2005-Jan-31
Document File: 3 page(s) / 35K

Publishing Venue

IBM

Abstract

This article describes an apparatus and mechanism for autogenerating scripts, shortcuts and wizards by observing the patterns of interaction of a user with a software application via a graphical user interface. We give some details of how this mechanism works, what features it provides and how it can be useful for other software and/or system entities. Finally, we give same sample scenarios to illustrate the idea.

This text was extracted from a PDF file.
This is the abbreviated version, containing approximately 36% of the total text.

Page 1 of 3

Autogenerating Scripts, Shortcuts, and Wizards Based on Human Interaction

Introduction

Many software products are administered using a graphical user interface of some sort. By nature, this is a highly interactive mode of human-to-software communication. Interactive consoles have solved many of the problems associated with the intricacies of administering a software product. However, there remain cases when customers and administration personnel need to customize the software that they use for their administrative and operational tasks. For example, some tasks may be repetitive where it would be more productive to use a script that reads input data from a file. Another example is that some programs may need to perform administrative tasks themselves and therefore they need to have a way to interface with the administration component of the software product. At times, the built in scripts in products are not sufficient to address their tasks and needs. Hence, customers would have to customize their scripts which means requiring them to learn the scripting language used.

The Proposed Solution

We describe an automated method for autogenerating scripts, thus, addressing the pain point described earlier. A user does not have to learn a new scripting language in order to create and customize useful scripts. At the same time, the user can still take advantage of the administration console whenever appropriate.

The approach is formulated from an observation model. The autogeneration is done by observing a user's interaction with a graphical interface (e.g. administrative console) and generating an "equivalent" program, such as scripts, shortcuts, an alternate executable, wizard, etc. By "equivalent", it is meant that given the same preconditions and inputs to the system, the final postconditions are the same. The intent is to minimize or completely remove human interaction from the picture (e.g., parameters or inputs may be provided from a stream). The premise is that this transformation can and will facilitate other processes where the equivalent program or script may become a part of a build checkout test, regular administrative task, etc.

The crux of this proposed solution is to realize that the user's interactions are a means to an end. This being the collection of parameters necessary to enact an action or task. The exact user interactions (keyboard, mouse, touchscreen, etc) are important only in so much as they provide the navigations used to collect the parameters needed to enact an action or actions. Therefore, the user's interactions can be generalized into a collection of parameters to enact a task or action. If the current state of the user driven program is germane, then this state can be passed to the action as another parameter. This equivalent program/action then allows for headless equivalent actions that can be used to automate tasks. Known solutions include pre-built automation scripts and self-install tools (e.g. IBM de...