Browse Prior Art Database

Progress Monitor Object for Status Updates during Long-Term Tasks

IP.com Disclosure Number: IPCOM000117955D
Original Publication Date: 1996-Jul-01
Included in the Prior Art Database: 2005-Mar-31
Document File: 4 page(s) / 110K

Publishing Venue

IBM

Related People

Pascoe, CJ: AUTHOR [+2]

Abstract

Disclosed is a method for passing status information (both text messages and absolute progress) from within an object performing a long sequence of tasks to a software application. This method is useful for programmers who want to build applications that give constant, useful feedback to users, assuring them that the application is still making progress.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 49% of the total text.

Progress Monitor Object for Status Updates during Long-Term Tasks

      Disclosed is a method for passing status information (both text
messages and absolute progress) from within an object performing a
long sequence of tasks to a software application.  This method is
useful for  programmers who want to build applications that give
constant, useful feedback to users, assuring them that the
application is still making progress.

      Application Programming Interface (API) libraries, both
procedural and object-oriented, provide a collection of interfaces
which perform specific tasks for the programmer.  Most of these tasks
take a short amount of time (as measured by humans) to be completed,
certainly within several seconds.

      However, some tasks (for example, configuration of network
server software) may take a much longer time, perhaps several
minutes.  The general call/return paradigm means the programmer calls
the API and does not receive any status information until the API
returns.  To the end-user of the software product, this period of
time often requires trust that work is continuing (the program has
not hung).

      Previous solutions to the problem have included the printing of
a sequence of periods or animated icons to imply work is still
continuing.  However, these are often implemented by spinning off a
separate thread that has no idea whether progress is still being
made; the "motion" continues even if the thread performing the actual
work is hung and progress has stopped.

      The specific requirement placed upon us by our customer was to
provide a continual flow of information during execution of the task,
including text indicating what sub-tasks were being performed and,
mathematically, how far through the task sequence.

      The solution was to define a new interface for receiving status
information, then allow that interface to be passed in to the API.
Our API can then call this interface as information the calling
program may be interested in becomes available.  Our specific
implementation is object-oriented, but the process can be applied in
a procedure-oriented environment, also.

      The first step was to define a ProgressMonitor object--an
object designed to receive and process status information.  In IBM's
System Object Model* (SOM) Interface Definition Language (IDL), the
definition is:
  struct ProgressMessage {
    string type_name;         // Identifier of the resource manager
who
                         // generated the message
    string catalog:    // Name of the message catalog where the
message
                        // is located (optional)
    long key;                 // Message's identification number
    string default_msg;   // A default message to be used if the
message
                       // catalog is unavailable (optional).
Positional
 ...