Browse Prior Art Database

Method for Developing High Level Programming Interface Capabilities

IP.com Disclosure Number: IPCOM000106927D
Original Publication Date: 1992-Jan-01
Included in the Prior Art Database: 2005-Mar-21
Document File: 4 page(s) / 189K

Publishing Venue

IBM

Related People

Broussard, SJ: AUTHOR

Abstract

Described is a method for developing application programmer interface (API) capabilities. The method provides high-level algorithms, programs and tools so that a programming function can be used across applications and operating system routines utilizing message passing architecture. (Image Omitted)

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

Method for Developing High Level Programming Interface Capabilities

       Described is a method for developing application
programmer interface (API) capabilities.  The method provides
high-level algorithms, programs and tools so that a programming
function can be used across applications and operating system
routines utilizing message passing architecture.

                            (Image Omitted)

      The method provides an algorithm function that can be
effectively shared by different programs in a system and a means for
efficiently sharing code and functionality between different
operating systems and application components.  It involves the
packaging of robust high- level algorithms, operating system utility
programs, tools, or other complex processes in a reusable manner that
is application-independent, presentation-independent and
fault-tolerant.  It also provides progress notification through the
use of message passing procedures.

      Typically, APIs are provided to enable interface functionality
to an operating system.  System architectures provide the capability
for programmers to implement their own special-purpose programming
interfaces so that the functions can be shared between two or more
programs in the system.  The level of functionality provided by an
API is less than the functionality provided by a program that calls
the API in order to complete its purpose.  APIs provide low-level
operations that are reusable.  The high-level processing of a program
is not easily reusable because there are dependencies on specific
presentation formats, presentation modes or specific application data
structures.

      APIs are not fault-tolerant in that once an error is discovered
a predetermined specific course of action must be taken.  This may
involve simply returning an error to the caller or bypassing the
error and continuing.  Some systems handle a small set of hard errors
by presenting the user with a list of predefined choices; however,
individual programs in the system do not have the ability to change
the list of choices.  Often this list of choices is disabled and
cannot be considered tolerant of error situations.  Without some
message-passing mechanism, APIs are not able to notify the caller of
the progress of the processing without returning back to the caller.
A polling architecture requires multiple threads or processes in the
system to handle the high-level API processing and status reporting.
This causes it to be unnecessarily complex and inefficient because of
synchronization.

      It is common practice for a program that requires the
functionality of another program to start that program. Most
operating systems provide a means of executing another program as a
secondary process.  Programs are not intended to be run in both a
graphical mode or a text mode.  Message passing is used to
communicate between processes in a system, between windows on a
scre...