Electrical computers and digital processing systems: multicomput – Computer-to-computer data routing – Least weight routing
Reexamination Certificate
1997-11-21
2002-01-15
Courtenay, III, St. John (Department: 2151)
Electrical computers and digital processing systems: multicomput
Computer-to-computer data routing
Least weight routing
C709S241000
Reexamination Certificate
active
06339782
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Technical Field
The present invention relates in general to object-oriented computer systems. More specifically, the present invention relates to the field of Java object-oriented systems.
2. Background Art
The development of the EDVAC computer system of 1948 is often cited as the beginning of the computer era. Since that time, computer systems have evolved into extremely sophisticated devices that may be found in many different settings. Computer systems typically include a combination of hardware (e.g., semiconductors, circuit boards, etc.) and software (e.g., 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.
Object-oriented programming based on an object model is a new way of creating computer programs that has become very popular over the past several years. 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. By creating and re-using a group of well-tested objects, a more stable, uniform, and consistent approach to developing new computer programs can be achieved.
Java is a modern object-oriented programming language specially designed to create distributed object systems. Java offers many features and advantages that makes it a desirable programming language to use. First, Java is specifically designed to create small programs, commonly called applets, that can reside on the network in centralized servers, and delivered to the client machine only when needed. Second, Java is completely platform independent. A Java program can be written once and ran on any type of platform that contains a Java Virtual Machine (JVM). And third, Java is an object-oriented language, meaning that software written in Java can take advantage of the benefits of object-oriented programming.
One issue in object oriented programming, and Java programing in particular, is object persistence. Persistent objects, as opposed to transient objects, have a lifetime that transcends the lifetime of the program that created them. To make an object persistent, mechanisms must be put in place to allow the object to survive the process that creates it so it can be accessed by other processes.
One common approach to providing persistence is the use of a persistent mixin class of objects. In this approach all objects for which persistence is desired must have this persistent mixin class as a superclass somewhere in their class's inheritance lattice. Because a mixin class is required in the inheritance lattice, this method for providing object persistence cannot be used to provide persistence in a way that is orthogonal (i.e., independent) to the class of the object. Because the object persistence is not orthogonal to its class, the applications in which it can be used are limited.
Another approach which provides object persistence is “externalization”. Externalization is the means or protocol used in object-oriented programming for transferring data out of an object. In essence the “state data” that defines the attributes of an object are “externalized”, or written out of the object into a local data store in a format compatible with the local data store. When the object is needed again, the externalized state data is internalized into an object, creating an exact copy of the object as it previously existed. Unfortunately, the process of externalizing the state data for storage and then internalizing it again when needed takes an excessive amount of processing time and thus slows performance in a way that can be unacceptable in many applications.
As the use of the Java programming language increases, the need for a persistent object mechanism that works becomes more apparent. Without a mechanism that can be used to efficiently provide persistent objects in a Java programming environment, the computer industry will never fully realize the potential of the Java language.
DISCLOSURE OF INVENTION
According to the present invention, a method and apparatus for providing persistence to programming languages that do not have their own persistence storage systems, such as Java, is provided. The preferred method and apparatus utilize a Java object persistence mechanism to provide object persistence in way that can be adapted for use in a wide variety of situations. In the preferred embodiment, the Java object persistence mechanism is implemented by defining a StoragePlugin class of objects. The class of objects includes the methods needed to provide orthogonal persistence in the Java environment. StoragePlugin objects are then instantiated as needed from the StoragePlugin class. Each StoragePlugin object implements the defined methods in a way that is compatible with a particular persistent storage system that is to be used (i.e., a particular hardware and database system).
REFERENCES:
patent: 6035119 (2000-03-01), Massena
patent: 6216152 (2001-04-01), Wong et al.
patent: 6272536 (2001-08-01), Van Hoff et al.
Kleindienst et al, “Lessons Learned From Implementing the CORBA Persistent Object Service”; OOPSLA '96 ACM digital library, pp 150-167, 1996.*
David Channon; “Persistence for C++”, Dr. Dobb's Journal; v21 n10 p46(7), Oct. 1996.*
Author Unknown, “Java Object Persistence: Technical Overview”, Sep. 1996.*
Atkinson et al, “An Orthogonally Persistent Java” ACM, Dec. 1996.*
Morrison et al, “Can Java Persist”, First International Workshop on Persistence and Java, Sep. 16-18, 1996.*
Java Soft, Java Native Interface Specification, May 1997.*
Daniel Berg, “Java Threads : A White Paper”, Mar. 1996.*
Crawley et al; “Orthogonal Persistence & Ada” ACM, pp 298-308, Feb. 1994.*
Mick Jordan, “Early Experiences With Persistent Java”, First International Workshop on Persistence & Java, Sep. 16-18, 1996.*
Atkinson et al, “Design Issues for Persistent Java : A type-safe, Object-oriented, Orthogonally Persistent System”, Mar. 1996.
Gerard Scott Neal
Halter Steven Lester
Courtenay III St. John
Pitts S. Jared
Schmeiser Olsen & Watts LLP
LandOfFree
Persistence mechanism and method for objects does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Persistence mechanism and method for objects, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Persistence mechanism and method for objects will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2844618