Data processing: software development – installation – and managem – Software program development tool – Code generation
Reexamination Certificate
1995-05-08
2004-01-13
Chavis, John (Department: 2124)
Data processing: software development, installation, and managem
Software program development tool
Code generation
C717S109000, C717S113000
Reexamination Certificate
active
06678880
ABSTRACT:
FIELD OF THE INVENTION
The present invention is directed to computers which operate with object-oriented programs, and more particularly to a system which permits the hierarchy of objects in an object-oriented computing environment, as well as the characteristics of those objects, to be dynamically designed and modified.
BACKGROUND OF THE INVENTION
Object-oriented programming of computers is gaining increasing popularity, in large part due to the great deal of flexibility which it offers with a relatively simple structure. Generally speaking, an object-oriented program comprises a collection of software entities known as objects, each of which is responsible for performing a particular task. Every object is characterized by associated properties, or data values, and one or more handlers that provide certain behavior or functionality. In operation, one object invokes the handlers of another object, to cause the second object to exhibit its associated behavior.
The behavior and properties of a given object can be extended to other objects through an inheritance structure. In such a structure, groups of associated objects can be organized in a hierarchical inheritance tree. In this type of arrangement, an object at a particular level of the hierarchy will inherit the properties and behavior of objects at higher levels from which it descends. Similarly, its property and behavior, including that inherited from higher-level objects, is passed on to lower-level objects that descend from it in the hierarchy.
The inheritance of object properties and handlers in an object-oriented program provides a number of desirable characteristics. Foremost among these is the reusability of software. Since an object at a lower level of the hierarchy inherits all of the behavior of objects at higher levels, the program code that provides particular behavior does not have to be rewritten for each object that is to exhibit that behavior. Consequently, fewer instances of that code exist in the program, and the debugging and testing of that portion of the code is therefore simplified. Another desirable aspect of inheritance is the consistency of interfaces that are provided. All objects which inherit from the same object or set of objects at a higher level of the hierarchy will exhibit the same properties and behavior, and thus present a consistent interface to the user.
Programming in an object-oriented system requires the programmer to build a structure for the set of objects, which defines how properties and handlers are to be inherited. Designing such a structure can be a complex and difficult task. Typically, the programmer doesn't begin the design of the code with the optimum structure in mind at the outset. Rather, as the program is developed, the designer typically discovers desirable variations to the original structure. For example, the designer may discover that a number of objects share a common attribute, and therefore should descend from a common parent to encapsulate that attribute. During development, the overall structure of the object-oriented program, i.e., its inheritance hierarchy, is typically modified over several iterations in such a fashion.
In the past, most program code for object-oriented systems has been text-based. More particularly, the relationships between objects in the hierarchy was described by means of a text file. From this text file, a database was built in working memory, e.g. RAM, to define the relationships during the run-time of the computer. Redesigning of the hierarchy in such systems involved changing the text scripts that defined the hierarchical relationships of the objects. These types of changes required the programmer to manually search through all of the files to find relevant portions of code and objects, and make the required changes. Typically, this was carried out by means of rather crude search and replace operations.
The redesigning of the code structure was even more complicated for object-oriented systems which support multiple inheritances. In these types of systems, an object can descend from, i.e. inherit properties and handlers from, more than one parent object at higher levels of the structure. The term “heterarchy” is used to describe the structure which exists in this type of system. A heterarchy differs from a conventional hierarchy by virtue of the fact that, in a hierarchy each object descends from one, and only one, parent object, whereas in a heterarchy each object can directly descend from more than one parent object. When an object descends from two or more parents, the parents are given a relative priority, or precedence, with respect to that object, in the event that some of their properties and/or handlers are mutually exclusive to one another. Because the interrelationships of objects in a heterarchical structure is much more complex, redesigning such a structure becomes significantly more difficult.
A particularly complex task in the redesign of the program structure is the addition and deletion of levels of the hierarchy or heterarchy. Typically, these kinds of changes involved writing new code to describe new objects in an added level or to remove references to objects in a deleted level, and then recompiling the program to incorporate the newly added code. Similarly, in the design of the program, if it became desirable to reorganize properties or handlers, for example to transfer a property from a descendant object to a newly added parent object, the associated code had to be rewritten and then recompiled.
It is desirable, therefore, to provide a system which permits a user to dynamically design and rearrange object structure, as well as design and rearrange the properties and handlers for an object after the structure has been redesigned, without the need to rewrite and recompile code.
SUMMARY OF THE INVENTION
In accordance with the present invention, this objective is achieved in an object-oriented computing environment by storing information relating to objects in a data file, and manipulating the information in the data file through a suitable user interface. The interface permits a user to completely redesign the program structure by adding or removing parents of an object through simple actions such as menu commands or drag and drop operations. In addition, the precedence of parents in a heterarchy can be reordered, again through a drag and drop operation. Furthermore, layers can be added to, or delete from, the program structure. For example, a new parent can be spliced between an existing parent and its children. Properties and handlers can be moved to appropriate levels of the program structure through simple operations, and the user can be provided with choices to make appropriate functionality changes to individual objects, as desired.
Further features of the invention, and the advantages offered thereby, are explained in detail hereinafter with reference to specific embodiments illustrated in the accompanying drawings.
REFERENCES:
patent: 5119475 (1992-06-01), Smith et al.
patent: 5339433 (1994-08-01), Frid-Nielsen
patent: 5410648 (1995-04-01), Pazel
patent: 5418964 (1995-05-01), Conner et al.
patent: 5432903 (1995-07-01), Frid-Nielsen
patent: 5455599 (1995-10-01), Cabral et al.
patent: 5493680 (1996-02-01), Danforth
patent: 5499371 (1996-03-01), Henninger et al.
patent: 5537630 (1996-07-01), Berry et al.
patent: 5546519 (1996-08-01), Berry
patent: 5560014 (1996-09-01), Imamura
patent: 5572733 (1996-11-01), Ryu et al.
patent: 5642511 (1997-06-01), Chow et al.
patent: 5644771 (1997-07-01), Endicott et al.
patent: 5692195 (1997-11-01), Conner et al.
patent: 5699310 (1997-12-01), Garloff et al.
patent: 5761511 (1998-06-01), Gibbons et al.
patent: 5832487 (1998-11-01), Olds et al.
patent: 6070006 (2000-05-01), Iriuchijima et al.
Myers et al, “Environment for Rapidly Creating Interactive Design Tools”, The Visual Computer, vol. 8, #2, 1992, pp. 94-116.*
Petyold, C., “The Visual Development Environment, More Than Just a Pretty Face”, Jun. 16, 1992, PC Magazine, pp 195-200, 204, 206, 209, 210, 215, 216, 221
Apple Computer Inc.
Burns Doane Swecker & Mathis L.L.P.
Chavis John
LandOfFree
System for iteratively designing an object heterarchy in an... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with System for iteratively designing an object heterarchy in an..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and System for iteratively designing an object heterarchy in an... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3220849