Implementation for an object oriented run-time extensible item

Details Implementation for an object oriented run-time extensible item Implementation for an object oriented run-time extensible item

1999-04-14

2001-08-14

Dam, Tuan Q. (Department: 2122)

Data processing: software development, installation, and managem

Software program development tool

Translation of code

C717S152000, C709S241000, C707S793000

Reexamination Certificate

active

06275979

ABSTRACT:

BACKGROUND OF THE INVENTION
1. Technical Field
This invention generally relates to object oriented programming and more specifically relates to an implementation for a run-time extensible item.
2. Background Art
Since the dawn of the computer age, computer systems have evolved into extremely sophisticated devices, and computer systems may now be found in many different settings. Computer systems typically include a combination of hardware, such as semiconductors and circuit boards, and software, also known as computer programs. As advances in semiconductor processing and computer architecture push the performance of the computer hardware higher, more sophisticated computer software has evolved to take advantage of the higher performance of the hardware, resulting in computer systems today that are much more powerful than just a few years ago.
Computer systems typically include operating system software that controls the basic function of the computer, and one or more software application programs that run under the control of the operating system to perform desired tasks. For example, a typical IBM Personal Computer may run the OS/2 operating system, and under the control of the OS/2 operating system, a user may execute an application program, such as a word processor. As the capabilities of computer systems have increased, the application software programs designed for high performance computer systems have become extremely powerful. Additionally, software development costs have continued to rise because more powerful and complex programs take more time, and hence more money, to produce.
One way in which the performance of application software programs has been improved while the associated development costs have been reduced is by using object oriented programming concepts. The goal of using object oriented programming is to create small, reusable sections of program code known as “objects” that can be quickly and easily combined and re-used to create new programs. This is similar to the idea of using the same set of building blocks again and again to create many different structures. The modular and re-usable aspects of objects will typically speed development of new programs, thereby reducing the costs associated with the development cycle. In addition, by creating and re-using a comprehensive set of well-tested objects, a more stable, uniform, and consistent approach to developing new computer programs can be achieved.
A central concept in object oriented programming is the “class.” A class is a template that defines a type of object. A class outlines or describes the characteristics or makeup of objects that belong to that class. By defining a class, objects can be created that belong to the class without having to rewrite the entire definition for each new object. This feature of object oriented programming promotes the reusability of existing object definitions and promotes more efficient use of program code.
Frameworks are relatively recent developments in object oriented programming that provide a group of pre-packaged classes and class relationships that are designed to help a user easily extend the framework to develop a particular software program, such as a software application. One framework that is commercially available from IBM is known as San Francisco, which provides pre-defined classes that allow a user to easily extend the framework to define a custom software application, such as a general ledger or an order processing system. Version 1.2 of the San Francisco framework defines a special type of domain-neutral object mechanism referred to herein as an extensible item. An extensible item can be dynamically reconfigured at run-time by adding or deleting domain-specific extensions to the extensible item object. An extensible item that holds a particular primary extension logically becomes an object of the type defined by the primary extension, thereby becoming domain-specific. In this manner the extensible item, which is domain-neutral, can acquire domain-specific extensions that define behavior that allows the extensible item to function as though it were domain-specific itself.
Each extensible item in the San Francisco framework contains a method table that pairs method names with corresponding method nodes. When a method on an extensible item is invoked, the extensible item determines which method node in the method table corresponds to the invoked method, and calls an execute( ) method on the corresponding method node. The method node, in turn, invokes the actual method on the appropriate instance, be it an extension to the extensible item or the extensible item itself.
Because the extensible item contains the method table, which in turn contains all method nodes that correspond to the extensible item and all of its extensions, the memory requirements (referred to as the “footprint”) for an extensible item may be quite large. In addition, creating or deleting an extension to an extensible item is a time-consuming process. If extensible items were rarely added, this performance problem would be unimportant. However, the very purpose of providing extensible items is to allow dynamically adding and deleting extensions to the extensible items, so extensions are frequently added and deleted from extensible items. Without a way to reduce the memory footprint for extensible items and for reducing the run-time penalty of adding extensions to extensible items, the performance of an application that is developed using the San Francisco framework will be impaired.
DISCLOSURE OF INVENTION
In an object oriented computer system, one or more run-time extensible items are defined that may be dynamically reconfigured as required to support different interfaces at run-time. The behavior associated with these interfaces is supported by one or more extensions owned by the extensible item. Each extension class has a corresponding method table that is shared among instances of the extension class and that correlates the methods defined on the extension class to method node objects that carry out the method. A method repository is a static object that is created at run-time to correlate extensions to their corresponding method tables. When a client invokes an invokeMethod( ) method on an extensible item, specifying the name of the method to be invoked, the extensible item cycles through its extensions, from newest to oldest, looking for an extension that supports the named method. Each extension examines the method repository to see if the method repository contains a method table corresponding to the extension class. If not, a method table corresponding to the extension class is created and placed in the method repository. When an extension is found that supports the named method, a method node that corresponds to the named method is returned. The method node then invokes the named method on the extension.
The foregoing and other features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings.


REFERENCES:
patent: 5740440 (1998-04-01), West
patent: 5867709 (1999-02-01), Klencke
patent: 5878432 (1999-03-01), Misheski et al.
patent: 5905987 (1999-05-01), Shutt et al.
patent: 6049665 (2000-04-01), Branson et al.
patent: 6104874 (2000-08-01), Branson et al.
patent: 6106569 (2000-08-01), Bohrer et al.
patent: 6173439 (2001-01-01), Carlson et al.
Ancona et al., “First Class Functions and Dynamic Binding of Methods to Classes,” IEEE Twelfth Annual Int'l Phoenix Conf. on Computers and Communications, Mar. 23-26, 1993, pp. 217-223.*
Rene W. Schmidt, “Dynamically Extensible Objects in a Class-Based Language,” IEEE Tools 23, Proceedings of Technology of Object-Oriented Languages and Systems, Jul.-Aug. 1997, pp. 294-305.*
Saeki et al., “Extensible Multimedia Class Library for Object-Oriented Database Systems,” IEEE Proceedings of Ninth International Workshop on Database and Expert Systems Applications, Aug. 26-28, 1998, pp. 893-900.

Affiliated with

Also associated with

Rating

Implementation for an object oriented run-time extensible item does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Implementation for an object oriented run-time extensible item, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Implementation for an object oriented run-time extensible item will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-2445357