CA2059577A1 - Object based system for software maintenance - Google Patents
Object based system for software maintenanceInfo
- Publication number
- CA2059577A1 CA2059577A1 CA002059577A CA2059577A CA2059577A1 CA 2059577 A1 CA2059577 A1 CA 2059577A1 CA 002059577 A CA002059577 A CA 002059577A CA 2059577 A CA2059577 A CA 2059577A CA 2059577 A1 CA2059577 A1 CA 2059577A1
- Authority
- CA
- Canada
- Prior art keywords
- event
- objects
- events
- initial
- dependency
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Abstract
ABSTRACT OF THE DISCLOSURE
Object Based System for Software Maintenance A computer implemented system and method for automatically generating an executable version is based on component objects and events. Object-oriented language concepts of encapsulation, inheritance, and message passing are employed to simplify the specification and execution steps. Software maintenance includes the steps of assembling executable systems from defined component parts such as source code files and object code files. An object definition is provided for each software component containing a specification of its dependency upon other objects and processing methods that must be executed to create that object. An event definition is created for each process that is to be applied to the component objects. The event definition includes a specification of any prerequisite events and conditions for delivery of the event message. An object dependency interpreter is provided to recursively control the passing of events to the objects for action. It ensures that any prerequisite events are first executed and that any objects upon which the current object is dependent are processed before the present object.
Inheritance is employed to simplify object definition through the definition of generic objects which the object dependency interpreter instantiates for processing. Mapped memory is used to store an object data structure containing the representation of component objects and event objects. Additional storage is used to retain component object file system status.
Object Based System for Software Maintenance A computer implemented system and method for automatically generating an executable version is based on component objects and events. Object-oriented language concepts of encapsulation, inheritance, and message passing are employed to simplify the specification and execution steps. Software maintenance includes the steps of assembling executable systems from defined component parts such as source code files and object code files. An object definition is provided for each software component containing a specification of its dependency upon other objects and processing methods that must be executed to create that object. An event definition is created for each process that is to be applied to the component objects. The event definition includes a specification of any prerequisite events and conditions for delivery of the event message. An object dependency interpreter is provided to recursively control the passing of events to the objects for action. It ensures that any prerequisite events are first executed and that any objects upon which the current object is dependent are processed before the present object.
Inheritance is employed to simplify object definition through the definition of generic objects which the object dependency interpreter instantiates for processing. Mapped memory is used to store an object data structure containing the representation of component objects and event objects. Additional storage is used to retain component object file system status.
Description
20~9~77 OBJECT BASED SYSTEM FOR SOFTWARE MAINTENANCE
Background of the Invention 1. Field of the Invention The present invention is directed to apparatus and methods for maintaining computer software objects, and in particular is directed to a system based on object-oriented concepts using objects to represent system components and processes to be applied to those components.
Background of the Invention 1. Field of the Invention The present invention is directed to apparatus and methods for maintaining computer software objects, and in particular is directed to a system based on object-oriented concepts using objects to represent system components and processes to be applied to those components.
2. Backqround and Prior Art Software systems are constructed by creating a number of source code programs that are compiled and linked together to form an executable system. Software maintenance is the process of changing and adapting software to correct errors, or to enhance or change function. Software maintenance includes assuring that the executable software system (the execution version) contains all modifications that have been made to the component source programs. Execution version currency can be assured by recompiling and relinking all components of a software system each time one of the source programs is changed. However, as the size of software systems has grown this technique becomes increasingly impractical.
Large software systems, such as operating systems software, and significant application programs, may be comprised of hundreds, thousands, or tens of thousands separate source code programs. These source code programs are interrelated in a manner specified by the software system architecture designer. The interrelationship of the pieces of a software system can be represented as a hierarchical dependency graph. For example, in Fig. 1, the software system called "topone"
is based upon three components, first.o, second.o, and 2 ~ 7 ~
third.o. Each of these, in turn, is dependent upon other programs, e.g. first.o is dependent upon firs-t.c and first.h.
The dependency network for a software system typically identifies source program modules and intermediate components which are eventually assembled to create the finished software system. The generation of intermediate modules and the final system product is carried out by de~ined executable processes. The most frequently employed function is compilation transforms a source code program into an object code module containing machine language instructions necessary to carry out the steps defined in the source code. For example, the object module in Fig. 1 entitled first.o is created by compiling first.c together with first.h. (This example is based on programs coded in the C language, however, the principles are extensible to any compiled or interpreted language such as FORTRAN, PASCAL, ADA, or to assembly language.) The second fre~uently used process is the binding or link editing of object code files to form an executable module. The binding step includes the process necessary to interrelate object code so that references to variables, memory locations, and other factors are fully resolved so the resulting module can be loaded into a computer system and executed.
It is desirable in large software systems to perform compilation, binding, and other processes only to the extent required by changes to the source programs or to the software architecture definition defininy the relationships between the programs. An attempt to manually perform only the necessary processes is subject to error and omission as the size of software systems grow. Automated tools for software maintenance have been developed to automatically determine the necessary changes and execute the required processes. One such tool is the "make" utility found in UNIX-based systems (UNIX is a trademark of UNIX Systems Laboratories).
2~59577 Make uses an acyclic dependency graph specified in a computer ~ile (known as a Makefile). Each node in the graph has a Make rule which is executed to produce a new version of the parent node if any child node has changed.
The Makefile for an executable program A.out is shown in Fi~. 2. The first line indicates that A.out is dependent( ~IG~
upon xl.o and x2.o. If either of these is found to be out of date the command "cc xl.o x2.o" is executed. This j ~--performs a binding step of those two object modules. The third line indicates that xl.o is dependent upon xl.c.
If xl.o is out of date with respect to xl.c the command "cc-c xl.c is executed to compile the source program xl.d if its date is more recent than that of xl.o.
The Make utility, while capable of performing software maintenance, suffers from a lack of flexibility ~nd difficulty of use. A large software system would re~lire the specification of a large number o rules.
The dependencies and interrelationships of the modules in a Make file is implicit rather than explicit leading to difficulties in interpretation and checking of the files.
This leads to difficulties in maintaining the Make file when changes are made to the software architecture and inte~relationship.
A discussion of several other techniques and proposed alternatives is provided in U.S.P. 4,55~,~13 to Schmidt et al. The Schmidt et al. system is designed to assemble a software system based upon source programs located in a series of workstation on a local area network. The Schmidt et al. system provides an extension to the Make utility which is claimed to provide more efficient management of large software products in a distributed environment. Schmidt et al., however, still re~lire the specification of the complete architecture (system model) in a descriptor file.
Object-oriented software systems and object-oriented programming languages are being increasingly applied to the solution of large system software problems.
KI9-91-002 4 2 ~ 7 7 Object-oriented approaches are directed to the subdivision of a problem to smaller, more easily managed pieces. Object-oriented languages and systems encourage programming and development in terms of "objects".
Objects implement encapsulation by providing a single definition of the data and processes (known as methods) necessary to manage that object.
A second feature of object-oriented languages systems is the notion of inheritance. Inheritance allows one object to "inherit" or use the data or methods from another object. In this way, new, more specific objects can be defined by defining only the variances from a more general objeGt definition.
Encapsulation of objects requires that object data be manipulated or viewed by the use of one of the object methods. Each object is provided a set of operations providing a visible interface to other objects.
Communication between objects is accomplished by message passing where messages conforming to the visible interface specification are accepted and processed by that. A message passed to an object is analyzed by the object which itself selects a method by which it will react to that message.
Object-oriented concepts allow significant reusability of objects through the concept of instantiation. Instantiation allows a copy or instance of an object to be created from either a generic object description or another object using the principles of inheritance. The particular instance of the object has its own data and is permitted to override particular data in the generic object definition.
Inheritance allows an object instance to benefit from hidden data or methods in one or more superior objects. An object which inherits data or methods for more than one object is said to have multiple inheritance. Encapsulation of an object can be shown as 20~9~7~
in Fig. 2. Here an object designated 100 contains -the data description 110 and functions 112 and 11~. The object reacts in response to message 116 which causes a selection of one of the methods 112 or 114 for execution.
Fig. 3 illustrates the concept of multiple inheritance. Two objects A and B can be defined at 120, 122 respectively. Object C 124 is shown as inheriting the data and functions from each of the objects A and B
and can have its own additional data and methods. Object C is said to be multiply dependent on objects ~ and B.
The object-oriented approach provides an important way to subdivide a large problem such as large software system maintenance. The concepts of encapsulation, and inheritance provide a powerful tool for solving such large problems.
Summary of the Invention The present invention is directed to applying object-oriented techni~ues to the solution of large ~oftware maintenance problems. Software systems can be represented as objects which are in turn comprised of a plurality of other objects which, at the lowest level, represent physical source program files. In addition, the processes to be applied to the software objects can themselves be defined as methods within the objects. The application of processes to particular source files can be accomplished using a message passing scheme. To control the processing, messages are themselves created as objects having attributes to control the application of processes to system objects. These enhanced messages are known as events in the present system. The present invention includes an object dependency interpreter that analyzes object relationships and assures that events are ro~lted as required by those relationships.
Therefore, the present invention is directed at solving the technical problem of maintaining large ~059577 software systems comprlsed of a large number of software components.
Brief Description of the Drawinqs The preferred embodiment of the present invention will be described with reference to the following figures.
Fig. 1 is a dependency network showing an example of software component dependencies.
Fig. 2 is a schematic diagram of the component object and associated message.
Fig. 3 is a schematic representation of object inheritance.
Fig. 4 is a block diagram showing the major components of the present system.
Fig. 5 is a flow chart showing the processing steps of the object dependency interpreter according to the present invention.
Detailed Description of the Preferred Embodiment The present invention provides a system and method for maintaining software systems based upon defined software objects and events. The system provides an ability to define software objects and events, to create data structures representing the objects, and to interpretatively analyze object dependencies and structures to cause event processes to be applied to software objects as necessary to generate the final software system.
An overview of the system according to the present invention is shown in Fig. 4. Source files 210 contain the definitions of objects and events. Object and event 2059~77 definitions, in the preferred embodiment, are created as a series of text files with descriptors providing for -the definition of object attributes and methods. The present invention, however, is not limited to the use o text based source files and is equally applicable to object definition files generated throuyh a graphical interface or similar techniques. A software object, in the preferred embodiment, includes an object descriptor giving a name to the object and one or more attributes.
Object attributes can include assignment of a value to a variable, the specification of object dependencies, the association of an event with an object method, or the definition of the process statements comprising an object method. Of particular importance to the present invention is the provision of a dependency list. A
dependency list attribute specifies the objects on which the current object depends. For example, an object code object may be dependent upon one or more source code objects or library objects.
An object method defines the executable statements which must be processed to create the current software object. The method specifies what must be done with dependent objects and variables in order to create the present object. Thus, in the above example, the method for creating an object code object may involve the compilation of dependent source code files. The methods may be generalized to be able to recognize different types of source code files and apply the appropriate compiler or compiler options as a result of that recognition.
Generic objects may be defined for common situations. For example, the creation of an object file for a C language source file requires common compilation steps. A generic object can be defined for any C object code file specifying the necessary object methods. When the system needs to use a gener.ic object, the object is instantiated for the particular object name and attributes are overridden to supply object dependencies, 20~577 if necessary. Where a convention is followed such that the object code file and the source code file have the sams name (e g. xl.o and xl.c) the no attribute replacement is required.
The source files also contain object definitions for events. As discussed above, events define the processes to be applied to the software objects. Event names correspond to method names and serve as messages to cause the objects to perform the necessary function. Event definitions according to the present invention include the provision of event conditions and prerequisite events to control the software maintenance process. Event conditions specify software object states that must be satisfied before the event is delivered to a software object. In the preferred embodiment, the conditions include: no condition~ meaning that no object condition must be met; out of date, meaning that the software object must be out of date with respect to its dependencies; object exists, meaning that the object must be found in the file system; no object exists; and object built, meaning that the object was created by the npplication of an object method (as opposed to being entered by a human operator).
Prerequisite events specify any events that must be delivered to an object before this event may be delivered.
In the preferred embodiment, event objects are provided with an additional precondition and post-condition which allow testing and error detection if the application of an event to a software object does not create the expected result. Thus, for example, the execution of a compile process for a software object sllould result in the condition that the object was built by that process. If a post-condition test reveals that the object is not in that condition, an error has occurred and the system should notify the operator.
2~9~7 The present invention next lncludes a parser 220 which parses the source files containing object definitions and event definitions into an intermediate "object assembly" languaye. The object assembly intermediate language provides a simplified form of object description that can be used to build object data structures in memory. Object assembly, in the preferred embodiment, is a series of one-byte operation codes that define the object, its attributes, and conditions.
Provision of a standard intermediate language allows the present invention to work with source files parsed by parser 220 or allows the definition of graphical input or different format source files which can be transformed into object assembly language by the application of an appropriate parser.
The next component of the present invention is object dependency interpreter engine 230. The object dependency interpreter controls the operation of the system by managing the passing of events to objects and causing the appropriate methods to be executed. The object dependency interpreter is a recursive process that evaluates each software object to determine its dependencies, and ensures that all lower level dependency conditions have been satisfied before the present object is evaluated. The object dependency interpreter also is responsible for instantiating specific instances of generic objects and for managing the inheritance properties between objects.
The preferred embodiment uses inheritance to minimize the number of definitions required in the software object definition section. A series of superclasses are defined that contain generic objects with generic dependencies and the methods required to generate that object. These generic objects include the data and methods required to compile different language source programs and to bind the resulting object modules together.
2~5~577 The present invention makes use of shared memory and mapped memory files to increase the speed object analysis and access. The object dependency interpreter 230 uses object assembly data to build an object data structure for each of the objects that find the source files 210.
This data structure is placed in the mapped memory area of a UNIX-based system. The mapped memory area provides the ability to save the memory area to a permanent disk file 231 and to restore that file to the memory at the same memory address. The ability -to restore the data at the same memory address simplifies the process of saving and restoring the file. The object dependency interpreter can continue to work with the object data ile in the mapped memory unless source files 210 have been modified. This eliminates the need to operate parser 220 and for object dependency interpreter 230 to build the object data on each location.
When interpreting event conditions, the object dependency interpreter must be able to determine the date of last update for source program files. In many prior art systems, this date was checked each time the source program was referenced during software maintenance. This multiple date checking greatly increased the overhead and slowed processing time in such software maintenance systems. In a large software environment containing a large file system and potential of shadowed filed trees, such repetitive date checking is undesirable. The present invention removes this limitation by checking the file status only once displaying the results in memory for any other reference.
Operation The software maintenance system according to the present invention operates as follows.
A software system architect builds object and event source files 210 using a text editor, a graphic editor, or other known device. The object definitions specify KI9-91-002 11 2 0 5 9 ~ 7 7 the system software architecture by specifying the dependencies for each module. Rvent objects are defined, including defining all processes to be applied to software objects and conditions for their application.
After making changes to a source program, a programmer or operator may wish to use the software maintenance system to create an updated executable version of the system. The operator invokes the software maintenance system and supplies an initial event and an object to which the event is to be applied. It is possible in the preferred embodiment to specify a default event and default initial object with the object and event descriptions. The system first determines whether the object data structure 231 is out of date with respect to the source files 210. If so, parser 220 is activated to parse the source files and pass the resulting object assembly to the object dependency interpreter. The object dependency interpreter is accessed and first builds the revised object data structure. In the preferred embodiment this structure is built in mapped memory. Operation will be described with reference to flow charts shown in Fig. 5. The object dependency interpreter 230 will first attempt to locate the specified object in the object data structure, step 302.
Once the object has been located, the interpreter tests to determine whether dependencies exist for that object.
If dependencies exist, the current object status is saved, for example in a stack, and the first dependent object is located, step 302. The locate object step 302 and test for dependencies step 304 are recursively executed until an object with no dependencies is located.
This object represents the lowest level or lead node in the object dependency hierarchy.
The interpreter next determines the condition of the object 308, for example, whether it is built, exists, or is out of date. The interpreter next tests this object condition against the condition specified in the event descriptor to determine a match 310. If the conditions 2~9~77 do not match the event is not delivered -to this object and processing continues by attempting to locate the parent object and to continue processing at step 316.
If the object condition matches the event condition, the event is to be delivered to the object. Interpreter 230 must determine whether the object definition associates a method with the specified event. If no method is associated with the event, the processing continues at step 316. If the method is associated, that method is executed at 314.
Step 316 determines whether delivery of the process to a higher level object has been deferred. If so, this object is once again accessed (e.g. removed from the stack) and the test for additional dependencies continues. Execution proceeds recursively in this manner until all dependencies for the highest level object have been satisfied. Finally, the object condition for the highest level event is tested and that highest level object is processed according to the same logic. Since no more objects exist at this point the interpreter exits.
Extensions to the preferred embodiment include the ability to build instances of generic objects. This would occur following step 302, when the system, if failing to locate the specific object in the data structure would seek to match the object name with the generic object defined in the data structure and if found, the specific object would be instantiated based upon the generic object. Similarly, when event associations are tested at step 312, the interpreter will search the object for the necessary method, and if not found will check all superclass objects from which the current object may inherit a method or attribute.
The object dependency interpreter also has the ability to detect prerequisite events or pre-events defined in the event definition. When the object 2~9~77 dependency interpreter detects a pre-event, processing of the current event is suspended and any prerequisite event is first processed. Processing of pre-events is also recursive in that any pre-events for identified pre-events are processed before that event. Processing of each of these events occurs according to the identified steps.
The preferred embodiment of the present invention has been described above in terms of specific steps and implementations. It will be recognized by those skilled in the art that alternative implementations are possible which will result in functionally equivalent processing.
It is therefore intended that the scope of the present invention be limited only by the appended claims.
The present invention provides significant advantages over the prior art. The use of object structures and object dependency interpreter simplifies both the specification of the objects, events, and dependencies, and provides for rapid processing necessary to maintain the software system.
Large software systems, such as operating systems software, and significant application programs, may be comprised of hundreds, thousands, or tens of thousands separate source code programs. These source code programs are interrelated in a manner specified by the software system architecture designer. The interrelationship of the pieces of a software system can be represented as a hierarchical dependency graph. For example, in Fig. 1, the software system called "topone"
is based upon three components, first.o, second.o, and 2 ~ 7 ~
third.o. Each of these, in turn, is dependent upon other programs, e.g. first.o is dependent upon firs-t.c and first.h.
The dependency network for a software system typically identifies source program modules and intermediate components which are eventually assembled to create the finished software system. The generation of intermediate modules and the final system product is carried out by de~ined executable processes. The most frequently employed function is compilation transforms a source code program into an object code module containing machine language instructions necessary to carry out the steps defined in the source code. For example, the object module in Fig. 1 entitled first.o is created by compiling first.c together with first.h. (This example is based on programs coded in the C language, however, the principles are extensible to any compiled or interpreted language such as FORTRAN, PASCAL, ADA, or to assembly language.) The second fre~uently used process is the binding or link editing of object code files to form an executable module. The binding step includes the process necessary to interrelate object code so that references to variables, memory locations, and other factors are fully resolved so the resulting module can be loaded into a computer system and executed.
It is desirable in large software systems to perform compilation, binding, and other processes only to the extent required by changes to the source programs or to the software architecture definition defininy the relationships between the programs. An attempt to manually perform only the necessary processes is subject to error and omission as the size of software systems grow. Automated tools for software maintenance have been developed to automatically determine the necessary changes and execute the required processes. One such tool is the "make" utility found in UNIX-based systems (UNIX is a trademark of UNIX Systems Laboratories).
2~59577 Make uses an acyclic dependency graph specified in a computer ~ile (known as a Makefile). Each node in the graph has a Make rule which is executed to produce a new version of the parent node if any child node has changed.
The Makefile for an executable program A.out is shown in Fi~. 2. The first line indicates that A.out is dependent( ~IG~
upon xl.o and x2.o. If either of these is found to be out of date the command "cc xl.o x2.o" is executed. This j ~--performs a binding step of those two object modules. The third line indicates that xl.o is dependent upon xl.c.
If xl.o is out of date with respect to xl.c the command "cc-c xl.c is executed to compile the source program xl.d if its date is more recent than that of xl.o.
The Make utility, while capable of performing software maintenance, suffers from a lack of flexibility ~nd difficulty of use. A large software system would re~lire the specification of a large number o rules.
The dependencies and interrelationships of the modules in a Make file is implicit rather than explicit leading to difficulties in interpretation and checking of the files.
This leads to difficulties in maintaining the Make file when changes are made to the software architecture and inte~relationship.
A discussion of several other techniques and proposed alternatives is provided in U.S.P. 4,55~,~13 to Schmidt et al. The Schmidt et al. system is designed to assemble a software system based upon source programs located in a series of workstation on a local area network. The Schmidt et al. system provides an extension to the Make utility which is claimed to provide more efficient management of large software products in a distributed environment. Schmidt et al., however, still re~lire the specification of the complete architecture (system model) in a descriptor file.
Object-oriented software systems and object-oriented programming languages are being increasingly applied to the solution of large system software problems.
KI9-91-002 4 2 ~ 7 7 Object-oriented approaches are directed to the subdivision of a problem to smaller, more easily managed pieces. Object-oriented languages and systems encourage programming and development in terms of "objects".
Objects implement encapsulation by providing a single definition of the data and processes (known as methods) necessary to manage that object.
A second feature of object-oriented languages systems is the notion of inheritance. Inheritance allows one object to "inherit" or use the data or methods from another object. In this way, new, more specific objects can be defined by defining only the variances from a more general objeGt definition.
Encapsulation of objects requires that object data be manipulated or viewed by the use of one of the object methods. Each object is provided a set of operations providing a visible interface to other objects.
Communication between objects is accomplished by message passing where messages conforming to the visible interface specification are accepted and processed by that. A message passed to an object is analyzed by the object which itself selects a method by which it will react to that message.
Object-oriented concepts allow significant reusability of objects through the concept of instantiation. Instantiation allows a copy or instance of an object to be created from either a generic object description or another object using the principles of inheritance. The particular instance of the object has its own data and is permitted to override particular data in the generic object definition.
Inheritance allows an object instance to benefit from hidden data or methods in one or more superior objects. An object which inherits data or methods for more than one object is said to have multiple inheritance. Encapsulation of an object can be shown as 20~9~7~
in Fig. 2. Here an object designated 100 contains -the data description 110 and functions 112 and 11~. The object reacts in response to message 116 which causes a selection of one of the methods 112 or 114 for execution.
Fig. 3 illustrates the concept of multiple inheritance. Two objects A and B can be defined at 120, 122 respectively. Object C 124 is shown as inheriting the data and functions from each of the objects A and B
and can have its own additional data and methods. Object C is said to be multiply dependent on objects ~ and B.
The object-oriented approach provides an important way to subdivide a large problem such as large software system maintenance. The concepts of encapsulation, and inheritance provide a powerful tool for solving such large problems.
Summary of the Invention The present invention is directed to applying object-oriented techni~ues to the solution of large ~oftware maintenance problems. Software systems can be represented as objects which are in turn comprised of a plurality of other objects which, at the lowest level, represent physical source program files. In addition, the processes to be applied to the software objects can themselves be defined as methods within the objects. The application of processes to particular source files can be accomplished using a message passing scheme. To control the processing, messages are themselves created as objects having attributes to control the application of processes to system objects. These enhanced messages are known as events in the present system. The present invention includes an object dependency interpreter that analyzes object relationships and assures that events are ro~lted as required by those relationships.
Therefore, the present invention is directed at solving the technical problem of maintaining large ~059577 software systems comprlsed of a large number of software components.
Brief Description of the Drawinqs The preferred embodiment of the present invention will be described with reference to the following figures.
Fig. 1 is a dependency network showing an example of software component dependencies.
Fig. 2 is a schematic diagram of the component object and associated message.
Fig. 3 is a schematic representation of object inheritance.
Fig. 4 is a block diagram showing the major components of the present system.
Fig. 5 is a flow chart showing the processing steps of the object dependency interpreter according to the present invention.
Detailed Description of the Preferred Embodiment The present invention provides a system and method for maintaining software systems based upon defined software objects and events. The system provides an ability to define software objects and events, to create data structures representing the objects, and to interpretatively analyze object dependencies and structures to cause event processes to be applied to software objects as necessary to generate the final software system.
An overview of the system according to the present invention is shown in Fig. 4. Source files 210 contain the definitions of objects and events. Object and event 2059~77 definitions, in the preferred embodiment, are created as a series of text files with descriptors providing for -the definition of object attributes and methods. The present invention, however, is not limited to the use o text based source files and is equally applicable to object definition files generated throuyh a graphical interface or similar techniques. A software object, in the preferred embodiment, includes an object descriptor giving a name to the object and one or more attributes.
Object attributes can include assignment of a value to a variable, the specification of object dependencies, the association of an event with an object method, or the definition of the process statements comprising an object method. Of particular importance to the present invention is the provision of a dependency list. A
dependency list attribute specifies the objects on which the current object depends. For example, an object code object may be dependent upon one or more source code objects or library objects.
An object method defines the executable statements which must be processed to create the current software object. The method specifies what must be done with dependent objects and variables in order to create the present object. Thus, in the above example, the method for creating an object code object may involve the compilation of dependent source code files. The methods may be generalized to be able to recognize different types of source code files and apply the appropriate compiler or compiler options as a result of that recognition.
Generic objects may be defined for common situations. For example, the creation of an object file for a C language source file requires common compilation steps. A generic object can be defined for any C object code file specifying the necessary object methods. When the system needs to use a gener.ic object, the object is instantiated for the particular object name and attributes are overridden to supply object dependencies, 20~577 if necessary. Where a convention is followed such that the object code file and the source code file have the sams name (e g. xl.o and xl.c) the no attribute replacement is required.
The source files also contain object definitions for events. As discussed above, events define the processes to be applied to the software objects. Event names correspond to method names and serve as messages to cause the objects to perform the necessary function. Event definitions according to the present invention include the provision of event conditions and prerequisite events to control the software maintenance process. Event conditions specify software object states that must be satisfied before the event is delivered to a software object. In the preferred embodiment, the conditions include: no condition~ meaning that no object condition must be met; out of date, meaning that the software object must be out of date with respect to its dependencies; object exists, meaning that the object must be found in the file system; no object exists; and object built, meaning that the object was created by the npplication of an object method (as opposed to being entered by a human operator).
Prerequisite events specify any events that must be delivered to an object before this event may be delivered.
In the preferred embodiment, event objects are provided with an additional precondition and post-condition which allow testing and error detection if the application of an event to a software object does not create the expected result. Thus, for example, the execution of a compile process for a software object sllould result in the condition that the object was built by that process. If a post-condition test reveals that the object is not in that condition, an error has occurred and the system should notify the operator.
2~9~7 The present invention next lncludes a parser 220 which parses the source files containing object definitions and event definitions into an intermediate "object assembly" languaye. The object assembly intermediate language provides a simplified form of object description that can be used to build object data structures in memory. Object assembly, in the preferred embodiment, is a series of one-byte operation codes that define the object, its attributes, and conditions.
Provision of a standard intermediate language allows the present invention to work with source files parsed by parser 220 or allows the definition of graphical input or different format source files which can be transformed into object assembly language by the application of an appropriate parser.
The next component of the present invention is object dependency interpreter engine 230. The object dependency interpreter controls the operation of the system by managing the passing of events to objects and causing the appropriate methods to be executed. The object dependency interpreter is a recursive process that evaluates each software object to determine its dependencies, and ensures that all lower level dependency conditions have been satisfied before the present object is evaluated. The object dependency interpreter also is responsible for instantiating specific instances of generic objects and for managing the inheritance properties between objects.
The preferred embodiment uses inheritance to minimize the number of definitions required in the software object definition section. A series of superclasses are defined that contain generic objects with generic dependencies and the methods required to generate that object. These generic objects include the data and methods required to compile different language source programs and to bind the resulting object modules together.
2~5~577 The present invention makes use of shared memory and mapped memory files to increase the speed object analysis and access. The object dependency interpreter 230 uses object assembly data to build an object data structure for each of the objects that find the source files 210.
This data structure is placed in the mapped memory area of a UNIX-based system. The mapped memory area provides the ability to save the memory area to a permanent disk file 231 and to restore that file to the memory at the same memory address. The ability -to restore the data at the same memory address simplifies the process of saving and restoring the file. The object dependency interpreter can continue to work with the object data ile in the mapped memory unless source files 210 have been modified. This eliminates the need to operate parser 220 and for object dependency interpreter 230 to build the object data on each location.
When interpreting event conditions, the object dependency interpreter must be able to determine the date of last update for source program files. In many prior art systems, this date was checked each time the source program was referenced during software maintenance. This multiple date checking greatly increased the overhead and slowed processing time in such software maintenance systems. In a large software environment containing a large file system and potential of shadowed filed trees, such repetitive date checking is undesirable. The present invention removes this limitation by checking the file status only once displaying the results in memory for any other reference.
Operation The software maintenance system according to the present invention operates as follows.
A software system architect builds object and event source files 210 using a text editor, a graphic editor, or other known device. The object definitions specify KI9-91-002 11 2 0 5 9 ~ 7 7 the system software architecture by specifying the dependencies for each module. Rvent objects are defined, including defining all processes to be applied to software objects and conditions for their application.
After making changes to a source program, a programmer or operator may wish to use the software maintenance system to create an updated executable version of the system. The operator invokes the software maintenance system and supplies an initial event and an object to which the event is to be applied. It is possible in the preferred embodiment to specify a default event and default initial object with the object and event descriptions. The system first determines whether the object data structure 231 is out of date with respect to the source files 210. If so, parser 220 is activated to parse the source files and pass the resulting object assembly to the object dependency interpreter. The object dependency interpreter is accessed and first builds the revised object data structure. In the preferred embodiment this structure is built in mapped memory. Operation will be described with reference to flow charts shown in Fig. 5. The object dependency interpreter 230 will first attempt to locate the specified object in the object data structure, step 302.
Once the object has been located, the interpreter tests to determine whether dependencies exist for that object.
If dependencies exist, the current object status is saved, for example in a stack, and the first dependent object is located, step 302. The locate object step 302 and test for dependencies step 304 are recursively executed until an object with no dependencies is located.
This object represents the lowest level or lead node in the object dependency hierarchy.
The interpreter next determines the condition of the object 308, for example, whether it is built, exists, or is out of date. The interpreter next tests this object condition against the condition specified in the event descriptor to determine a match 310. If the conditions 2~9~77 do not match the event is not delivered -to this object and processing continues by attempting to locate the parent object and to continue processing at step 316.
If the object condition matches the event condition, the event is to be delivered to the object. Interpreter 230 must determine whether the object definition associates a method with the specified event. If no method is associated with the event, the processing continues at step 316. If the method is associated, that method is executed at 314.
Step 316 determines whether delivery of the process to a higher level object has been deferred. If so, this object is once again accessed (e.g. removed from the stack) and the test for additional dependencies continues. Execution proceeds recursively in this manner until all dependencies for the highest level object have been satisfied. Finally, the object condition for the highest level event is tested and that highest level object is processed according to the same logic. Since no more objects exist at this point the interpreter exits.
Extensions to the preferred embodiment include the ability to build instances of generic objects. This would occur following step 302, when the system, if failing to locate the specific object in the data structure would seek to match the object name with the generic object defined in the data structure and if found, the specific object would be instantiated based upon the generic object. Similarly, when event associations are tested at step 312, the interpreter will search the object for the necessary method, and if not found will check all superclass objects from which the current object may inherit a method or attribute.
The object dependency interpreter also has the ability to detect prerequisite events or pre-events defined in the event definition. When the object 2~9~77 dependency interpreter detects a pre-event, processing of the current event is suspended and any prerequisite event is first processed. Processing of pre-events is also recursive in that any pre-events for identified pre-events are processed before that event. Processing of each of these events occurs according to the identified steps.
The preferred embodiment of the present invention has been described above in terms of specific steps and implementations. It will be recognized by those skilled in the art that alternative implementations are possible which will result in functionally equivalent processing.
It is therefore intended that the scope of the present invention be limited only by the appended claims.
The present invention provides significant advantages over the prior art. The use of object structures and object dependency interpreter simplifies both the specification of the objects, events, and dependencies, and provides for rapid processing necessary to maintain the software system.
Claims (13)
1. An information processing system for managing message passing between objects, said system comprising:
storage means for storing objects and events, said objects having a plurality of condition states, a plurality of attributes, and a plurality if methods, each of said methods having an identifier and specifying operations to be performed by said processing system, said attributes including a list of zero, one or more dependency objects on which this object depends, said events having a plurality of conditions;
initialization means for starting said system, said initialization means determining an initial object and an initial event;
dependency interpreter means for recursively identifying target objects on which said initial object and identified target objects depends based on said dependency objects, and for delivering said initial event to all of said identified target objects before delivering said event to said initial object;
delivery means for delivering said initial event to said target objects, said delivery means including means for testing said target object conditions to determine whether said event conditions are satisfied;
means for testing said target object methods, if said event conditions are satisfied, to determine whether a method for the event is associated for that object; and processing means for executing said method if said means for testing locates a method for said event.
storage means for storing objects and events, said objects having a plurality of condition states, a plurality of attributes, and a plurality if methods, each of said methods having an identifier and specifying operations to be performed by said processing system, said attributes including a list of zero, one or more dependency objects on which this object depends, said events having a plurality of conditions;
initialization means for starting said system, said initialization means determining an initial object and an initial event;
dependency interpreter means for recursively identifying target objects on which said initial object and identified target objects depends based on said dependency objects, and for delivering said initial event to all of said identified target objects before delivering said event to said initial object;
delivery means for delivering said initial event to said target objects, said delivery means including means for testing said target object conditions to determine whether said event conditions are satisfied;
means for testing said target object methods, if said event conditions are satisfied, to determine whether a method for the event is associated for that object; and processing means for executing said method if said means for testing locates a method for said event.
2. The system of Claim 1 further comprising:
source object storage means for storing source code descriptions of said objects;
event storage means for storing source code descriptions of said events;
parsing means for transforming said object and event source code descriptions into an intermediate language representation; and data structure means for building said objects and events into a data structure in said storage means.
source object storage means for storing source code descriptions of said objects;
event storage means for storing source code descriptions of said events;
parsing means for transforming said object and event source code descriptions into an intermediate language representation; and data structure means for building said objects and events into a data structure in said storage means.
3. The system of Claim 2 wherein said object definitions include generic objects having attributes and methods and wherein said system further comprises:
object instantiation means for identifying a generic object similar to said initial or target object and for generating an instance of said generic object with properties of said initial or target object.
object instantiation means for identifying a generic object similar to said initial or target object and for generating an instance of said generic object with properties of said initial or target object.
4. The system of Claim 3 wherein said instance inherits attributes and methods from said generic object.
5. A system for software maintenance, said system creating a current version of a software object from a plurality of software source files, said system comprising:
event storage means for storing events required to maintain said software object, each of said events having an event identifier, and one or more conditions;
object storage means for storing object definitions, each of said objects having an object identifier, a plurality of attributes, a plurality of conditions, and a plurality of methods describing operations to be performed by said management system, said attributes including at least one dependency object on which the current object depends, wherein said dependency objects represent a software object comprised of zero, one or more dependent objects, or is a reference to a source file;
operator interaction means for identifying an operator selected initial object and initial event;
dependency interpreter means for recursively identifying target objects on which said initial object and its dependency objects depend;
delivery means for delivering said initial event to said target objects, said delivery means including:
means for testing said target object conditions against said event conditions;
means for testing said target object methods to determine whether said target object has an associated method matching said event, if said event conditions are satisfied; and processing means for processing said associated method if an associated event is identified.
event storage means for storing events required to maintain said software object, each of said events having an event identifier, and one or more conditions;
object storage means for storing object definitions, each of said objects having an object identifier, a plurality of attributes, a plurality of conditions, and a plurality of methods describing operations to be performed by said management system, said attributes including at least one dependency object on which the current object depends, wherein said dependency objects represent a software object comprised of zero, one or more dependent objects, or is a reference to a source file;
operator interaction means for identifying an operator selected initial object and initial event;
dependency interpreter means for recursively identifying target objects on which said initial object and its dependency objects depend;
delivery means for delivering said initial event to said target objects, said delivery means including:
means for testing said target object conditions against said event conditions;
means for testing said target object methods to determine whether said target object has an associated method matching said event, if said event conditions are satisfied; and processing means for processing said associated method if an associated event is identified.
6. The system of Claim 5 wherein said event storage means and said object storage means comprises system random access memory beginning at a first address and wherein said system further comprises:
non-volatile system storage means for copying data in said event storage means and said object storage means to said non-volatile system storage; and means for copying data from said non-volatile storage to said event storage and said object storage so that said first address remains the same.
non-volatile system storage means for copying data in said event storage means and said object storage means to said non-volatile system storage; and means for copying data from said non-volatile storage to said event storage and said object storage so that said first address remains the same.
7. The system of Claim 6 further comprising:
event data entry means for entering event definitions; and object data entry means for entering object definitions.
event data entry means for entering event definitions; and object data entry means for entering object definitions.
8. The system of Claim 6 wherein said event data entry means and said object data entry means comprise a text entry system; and wherein said system further comprises:
parsing means for transforming text event and object data into an intermediate language; and data structure generation means for transforming said intermediate language into said object and event data structure in said random access memory.
parsing means for transforming text event and object data into an intermediate language; and data structure generation means for transforming said intermediate language into said object and event data structure in said random access memory.
9. The system of Claim 8 wherein said object definitions include generic objects having attributes and methods and wherein said system further comprises:
object instantiation means for identifying a generic object similar to said initial or target object and for generating an instance of said generic object with properties of said initial or target object.
object instantiation means for identifying a generic object similar to said initial or target object and for generating an instance of said generic object with properties of said initial or target object.
10. The system of Claim 9 wherein said instance inherits attributes and methods from said generic object.
11. The system of Claim 5 wherein said events further include prerequisite events that must be applied to objects before said event.
12. The system of Claim 5 wherein said event conditions include a delivery condition, a pre-application condition and a post-application condition, wherein failure of said pre-application or post-application conditions causes an error message to be generated.
13. The system of Claim 12 wherein the conditions are one of: object exists, object does not exist, built, out of date, or no condition.
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US64480491A | 1991-01-22 | 1991-01-22 | |
| US07/644,804 | 1991-01-22 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CA2059577A1 true CA2059577A1 (en) | 1992-07-23 |
Family
ID=24586399
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002059577A Abandoned CA2059577A1 (en) | 1991-01-22 | 1992-01-17 | Object based system for software maintenance |
Country Status (5)
| Country | Link |
|---|---|
| US (1) | US5493682A (en) |
| EP (1) | EP0496494A3 (en) |
| JP (1) | JPH0792748B2 (en) |
| BR (1) | BR9200055A (en) |
| CA (1) | CA2059577A1 (en) |
Families Citing this family (91)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5193180A (en) | 1991-06-21 | 1993-03-09 | Pure Software Inc. | System for modifying relocatable object code files to monitor accesses to dynamically allocated memory |
| US5539870A (en) * | 1992-10-05 | 1996-07-23 | International Business Machines Corporation | Computerized system and process for interactively managing a distributed database system |
| US5729746A (en) * | 1992-12-08 | 1998-03-17 | Leonard; Ricky Jack | Computerized interactive tool for developing a software product that provides convergent metrics for estimating the final size of the product throughout the development process using the life-cycle model |
| US5325533A (en) * | 1993-06-28 | 1994-06-28 | Taligent, Inc. | Engineering system for modeling computer programs |
| CA2128387C (en) * | 1993-08-23 | 1999-12-28 | Daniel F. Hurley | Method and apparatus for configuring computer programs from available subprograms |
| US5787440A (en) * | 1994-03-10 | 1998-07-28 | Crossties Software Corp. | Object oriented architecture with bidirectional linking of relationships between objects |
| JPH07262025A (en) * | 1994-03-18 | 1995-10-13 | Fujitsu Ltd | Execution control system |
| US5613063A (en) * | 1994-07-01 | 1997-03-18 | Digital Equipment Corporation | Method and apparatus for checking validity of memory operations |
| US6704744B1 (en) * | 1994-12-07 | 2004-03-09 | Next Computer, Inc. | Method and apparatus for mapping objects to multiple tables of a database |
| SE504050C2 (en) * | 1995-02-28 | 1996-10-28 | Ericsson Telefon Ab L M | Network device and method for connecting in a communication system a connection between two points by utilizing a number of connection objects |
| US5867713A (en) * | 1995-04-05 | 1999-02-02 | International Business Machines Corporation | Committing an install plan object for the network installation of application programs |
| US5805891A (en) * | 1995-07-26 | 1998-09-08 | International Business Machines Corporation | System and method for managing maintenance of computer software |
| US6112253A (en) * | 1995-10-12 | 2000-08-29 | International Business Machines Corporation | Object-oriented method maintenance mechanism that does not require cessation of the computer system or its programs |
| US5867709A (en) * | 1995-10-18 | 1999-02-02 | Kapre Software, Inc. | Method and system for reusing customizations to a software product |
| US6044377A (en) * | 1995-11-07 | 2000-03-28 | Sun Microsystem, Inc. | User-defined object type and method of making the object type wherein a file associated with a rule is invoked by accessing the file which generates code at run time |
| US5845077A (en) * | 1995-11-27 | 1998-12-01 | Microsoft Corporation | Method and system for identifying and obtaining computer software from a remote computer |
| US6298476B1 (en) * | 1995-12-04 | 2001-10-02 | International Business Machines Corporation | Object oriented software build framework mechanism |
| US5758349A (en) * | 1995-12-27 | 1998-05-26 | International Business Machines Corporation | Process and system for run-time inheritance and disinheritance of methods and data |
| US5966715A (en) * | 1995-12-29 | 1999-10-12 | Csg Systems, Inc. | Application and database security and integrity system and method |
| US6016498A (en) * | 1996-03-04 | 2000-01-18 | Bakke; Stephen Peter | Object oriented architecture with bidirectional linking of relationships between objects |
| US5706510A (en) * | 1996-03-15 | 1998-01-06 | Hewlett-Packard Company | Zymbolic history management system |
| EP0888585A1 (en) * | 1996-03-19 | 1999-01-07 | Massachusetts Institute Of Technology | Computer system and computer implemented process for representing software system descriptions and for generating executable computer programs and computer system configurations from software system descriptions |
| US5835777A (en) * | 1996-03-20 | 1998-11-10 | Hewlett-Packard Company | Method of automatically generating a software installation package |
| US6049671A (en) * | 1996-04-18 | 2000-04-11 | Microsoft Corporation | Method for identifying and obtaining computer software from a network computer |
| US5721824A (en) * | 1996-04-19 | 1998-02-24 | Sun Microsystems, Inc. | Multiple-package installation with package dependencies |
| US5790796A (en) * | 1996-06-14 | 1998-08-04 | Symantec Corporation | Polymorphic package files to update software components |
| US5708774A (en) * | 1996-07-23 | 1998-01-13 | International Business Machines Corporation | Automated testing of software application interfaces, object methods and commands |
| US6243763B1 (en) | 1996-11-12 | 2001-06-05 | International Business Machines Corporation | Method for sending a message to a group and the group broadcasts the message to its members or references within an object-oriented system |
| US6802061B1 (en) * | 1996-12-12 | 2004-10-05 | Microsoft Corporation | Automatic software downloading from a computer network |
| US6263376B1 (en) | 1997-02-24 | 2001-07-17 | Novell, Inc. | Generic run-time binding interpreter |
| AU6183798A (en) * | 1997-02-27 | 1998-09-29 | Siebel Systems, Inc. | Method of migrating to a successive level of a software distribution incorporating local modifications |
| US5974254A (en) * | 1997-06-06 | 1999-10-26 | National Instruments Corporation | Method for detecting differences between graphical programs |
| WO1998057260A1 (en) * | 1997-06-13 | 1998-12-17 | True Software, Inc. | Systems and methods for scanning and modeling dependencies in software applications |
| US6990458B2 (en) * | 1997-08-28 | 2006-01-24 | Csg Systems, Inc. | System and method for computer-aided technician dispatch and communication |
| US6167521A (en) * | 1997-08-29 | 2000-12-26 | International Business Machines Corporation | Securely downloading and executing code from mutually suspicious authorities |
| US6117187A (en) * | 1997-09-30 | 2000-09-12 | Hewlett-Packard Company | Automatic generation of a software installation package |
| US6898782B1 (en) | 1997-10-14 | 2005-05-24 | International Business Machines Corporation | Reference-based associations using reference attributes in an object modeling system |
| US6182277B1 (en) * | 1998-04-15 | 2001-01-30 | Oracle Corporation | Methods and apparatus for declarative programming techniques in an object oriented environment |
| US6381742B2 (en) * | 1998-06-19 | 2002-04-30 | Microsoft Corporation | Software package management |
| US6351752B1 (en) | 1998-07-08 | 2002-02-26 | Ncr Corporation | Method and apparatus for detecting changes to a collection of objects |
| US6226792B1 (en) * | 1998-10-14 | 2001-05-01 | Unisys Corporation | Object management system supporting the use of application domain knowledge mapped to technology domain knowledge |
| US7526468B2 (en) * | 1999-01-08 | 2009-04-28 | Computer Associates Think, Inc. | System and method for recursive path analysis of DBMS procedures |
| US7418435B1 (en) * | 1999-08-05 | 2008-08-26 | Oracle International Corporation | Multi-model access to data |
| WO2001088697A2 (en) * | 2000-05-17 | 2001-11-22 | Adc Telecommunications Israel Ltd. | Methods for modularizing network software |
| US8261255B1 (en) | 2000-11-07 | 2012-09-04 | International Business Machines Corporation | Method, system, and computer program product for maintaining software on a computer system with automatic dependency resolution |
| KR100388486B1 (en) * | 2000-12-14 | 2003-06-25 | 한국전자통신연구원 | Method and apparatus for identifying software components using object relationships and object usages in use cases |
| US20020087734A1 (en) * | 2000-12-29 | 2002-07-04 | Marshall Donald Brent | System and method for managing dependencies in a component-based system |
| DE10105454A1 (en) * | 2001-02-07 | 2002-08-29 | Bosch Gmbh Robert | Procedure for the automatic addition of software |
| US7290243B1 (en) * | 2001-02-28 | 2007-10-30 | Apple Inc. | Method and apparatus for application building using build styles |
| US6990638B2 (en) * | 2001-04-19 | 2006-01-24 | International Business Machines Corporation | System and method for using shading layers and highlighting to navigate a tree view display |
| US6765597B2 (en) | 2001-04-19 | 2004-07-20 | International Business Machines Corporation | System and method for using layer bars to indicate levels within non-indented tree view control |
| US7146601B2 (en) * | 2001-10-12 | 2006-12-05 | Sun Microsystems, Inc. | Method and apparatus for deriving functions from other functions in a programming language |
| US7280985B2 (en) * | 2001-12-06 | 2007-10-09 | New York University | Logic arrangement, data structure, system and method for multilinear representation of multimodal data ensembles for synthesis, recognition and compression |
| US20030191870A1 (en) * | 2002-04-02 | 2003-10-09 | Dominic Duggan | Method and apparatus for updating software libraries |
| US7334222B2 (en) * | 2002-09-11 | 2008-02-19 | International Business Machines Corporation | Methods and apparatus for dependency-based impact simulation and vulnerability analysis |
| US7096459B2 (en) * | 2002-09-11 | 2006-08-22 | International Business Machines Corporation | Methods and apparatus for root cause identification and problem determination in distributed systems |
| US7240325B2 (en) * | 2002-09-11 | 2007-07-03 | International Business Machines Corporation | Methods and apparatus for topology discovery and representation of distributed applications and services |
| US7505872B2 (en) * | 2002-09-11 | 2009-03-17 | International Business Machines Corporation | Methods and apparatus for impact analysis and problem determination |
| US6847970B2 (en) | 2002-09-11 | 2005-01-25 | International Business Machines Corporation | Methods and apparatus for managing dependencies in distributed systems |
| US7555749B2 (en) * | 2003-03-10 | 2009-06-30 | Microsoft Corporation | Software updating system and method |
| US7584467B2 (en) * | 2003-03-17 | 2009-09-01 | Microsoft Corporation | Software updating system and method |
| US7177865B2 (en) * | 2003-06-30 | 2007-02-13 | Sap Ag | Data synchronization method and system |
| US7379925B2 (en) * | 2003-07-25 | 2008-05-27 | New York University | Logic arrangement, data structure, system and method for multilinear representation of multimodal data ensembles for synthesis, rotation and compression |
| US20050144615A1 (en) * | 2003-12-29 | 2005-06-30 | Shu-Chuan Chen | Modularized custom-developed software package producing method and system |
| US7693299B2 (en) * | 2004-01-13 | 2010-04-06 | New York University | Method, system, storage medium, and data structure for image recognition using multilinear independent component analysis |
| US7496912B2 (en) * | 2004-02-27 | 2009-02-24 | International Business Machines Corporation | Methods and arrangements for ordering changes in computing systems |
| US7506332B2 (en) * | 2004-03-24 | 2009-03-17 | Sap Ag | Object set optimization using dependency information |
| GB2413409B (en) * | 2004-04-23 | 2006-10-11 | Oracle Int Corp | Data storage method and system |
| US20060064681A1 (en) * | 2004-09-23 | 2006-03-23 | Robinson Douglas B | Method and system for verifying makefile accuracy |
| US8131766B2 (en) * | 2004-12-15 | 2012-03-06 | Oracle International Corporation | Comprehensive framework to integrate business logic into a repository |
| US7921076B2 (en) * | 2004-12-15 | 2011-04-05 | Oracle International Corporation | Performing an action in response to a file system event |
| US8949455B2 (en) | 2005-11-21 | 2015-02-03 | Oracle International Corporation | Path-caching mechanism to improve performance of path-related operations in a repository |
| US8074213B1 (en) | 2006-08-11 | 2011-12-06 | Symantec Operating Corporation | Automatic software updates for computer systems in an enterprise environment |
| US8635599B2 (en) * | 2006-08-18 | 2014-01-21 | International Business Machines Corporation | System and method for evaluating adherence to a standardized process |
| US7636873B2 (en) * | 2006-09-15 | 2009-12-22 | International Business Machines Corporation | Enhancement of assured event delivery mechanism to eliminate external XA store requirement |
| US9600767B1 (en) * | 2006-10-06 | 2017-03-21 | Hrl Laboratories, Llc | System, method, and computer program product for generating a single software code based on a description of a distributed architecture |
| US8555247B2 (en) | 2006-10-13 | 2013-10-08 | International Business Machines Corporation | Systems and methods for expressing temporal relationships spanning lifecycle representations |
| US8229778B2 (en) | 2006-11-16 | 2012-07-24 | International Business Machines Corporation | Constructing change plans from component interactions |
| US8037471B2 (en) * | 2006-11-16 | 2011-10-11 | International Business Machines Corporation | Systems and methods for constructing relationship specifications from component interactions |
| US8745584B2 (en) * | 2007-05-03 | 2014-06-03 | International Business Machines Corporation | Dependency injection by static code generation |
| US9639331B2 (en) | 2008-07-09 | 2017-05-02 | International Business Machines Corporation | Service interface creation and modification for object-oriented services |
| US8291401B2 (en) * | 2008-08-07 | 2012-10-16 | International Business Machines Corporation | Processing symbols associated with shared assemblies |
| US8453141B1 (en) | 2009-01-29 | 2013-05-28 | Symantec Corporation | High performance install update |
| US8005929B1 (en) | 2009-02-27 | 2011-08-23 | Symantec Operating Corporation | Software update checking method |
| US8347294B2 (en) | 2009-10-14 | 2013-01-01 | Oracle International Corporation | Automated administration using composites of atomic operations |
| US8677339B2 (en) * | 2010-04-13 | 2014-03-18 | International Business Machines Corporation | Component relinking in migrations |
| US8490054B2 (en) | 2011-09-23 | 2013-07-16 | The United States Of America As Represented By The Secretary Of The Army | Software and related software tracking during software modification |
| US20150006350A1 (en) * | 2013-06-28 | 2015-01-01 | D.E. Shaw & Co., L.P. | Electronic Trading Auction with Randomized Acceptance Phase and Order Execution |
| US20150006349A1 (en) * | 2013-06-28 | 2015-01-01 | D. E. Shaw & Co., L.P. | Electronic Trading Auction With Orders Interpreted Using Future Information |
| US10769113B2 (en) | 2016-03-25 | 2020-09-08 | Microsoft Technology Licensing, Llc | Attribute-based dependency identification for operation ordering |
| US11829751B1 (en) * | 2020-12-23 | 2023-11-28 | Synopsys, Inc. | System and method for automatically capturing source code and associated artifacts for static analysis |
Family Cites Families (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US4330822A (en) * | 1971-09-02 | 1982-05-18 | Burroughs Corporation | Recursive system and method for binding compiled routines |
| US4558413A (en) * | 1983-11-21 | 1985-12-10 | Xerox Corporation | Software version management system |
| US4809170A (en) * | 1987-04-22 | 1989-02-28 | Apollo Computer, Inc. | Computer device for aiding in the development of software system |
| US4951192A (en) * | 1987-06-04 | 1990-08-21 | Apollo Computer, Inc. | Device for managing software configurations in parallel in a network |
| US5084813A (en) * | 1988-04-20 | 1992-01-28 | Kabushiki Kaisha Toshiba | Rule based system for synthesizing a program suited for a target system in response to an input target system specification |
| US5079695A (en) * | 1988-04-25 | 1992-01-07 | Hewlett-Packard Company | Object management facility which includes a snapshot facility for providing data transfer between two objects |
| US4953080A (en) * | 1988-04-25 | 1990-08-28 | Hewlett-Packard Company | Object management facility for maintaining data in a computer system |
| US5130924A (en) * | 1988-06-30 | 1992-07-14 | International Business Machines Corporation | System for defining relationships among document elements including logical relationships of elements in a multi-dimensional tabular specification |
| US5093915A (en) * | 1988-11-02 | 1992-03-03 | Xerox Corporation | Method for selectively loading bootable fiber to control apparatus based upon the corresponding bootable attributes |
-
1992
- 1992-01-07 EP EP19920300112 patent/EP0496494A3/en not_active Withdrawn
- 1992-01-10 BR BR929200055A patent/BR9200055A/en unknown
- 1992-01-10 JP JP4020744A patent/JPH0792748B2/en not_active Expired - Lifetime
- 1992-01-17 CA CA002059577A patent/CA2059577A1/en not_active Abandoned
-
1994
- 1994-10-26 US US08/329,792 patent/US5493682A/en not_active Expired - Fee Related
Also Published As
| Publication number | Publication date |
|---|---|
| BR9200055A (en) | 1992-09-08 |
| EP0496494A3 (en) | 1993-05-12 |
| JPH0792748B2 (en) | 1995-10-09 |
| EP0496494A2 (en) | 1992-07-29 |
| US5493682A (en) | 1996-02-20 |
| JPH0561683A (en) | 1993-03-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US5493682A (en) | Object based system for software maintenance | |
| Johnson et al. | Refactoring and aggregation | |
| JP4195479B2 (en) | Incremental generation system | |
| US5761510A (en) | Method for error identification in a program interface | |
| EP0664027B1 (en) | Program modeling system | |
| US6633888B1 (en) | Method and apparatus for visually creating and testing object oriented components | |
| Ierusalimschy et al. | Lua—an extensible extension language | |
| US8042097B2 (en) | Automated semantic-based updates to modified code base | |
| US6067641A (en) | Demand-based generation of symbolic information | |
| US6002867A (en) | Development system with methods providing visual form inheritance | |
| US5854932A (en) | Compiler and method for avoiding unnecessary recompilation | |
| US20060010425A1 (en) | Methods and apparatus for automated mangement of software | |
| US20060041879A1 (en) | System and method for changing defined user interface elements in a previously compiled program | |
| US6961931B2 (en) | Dependency specification using target patterns | |
| US20050065953A1 (en) | System and method for changing defined elements in a previously compiled program using a description file | |
| US6757887B1 (en) | Method for generating a software module from multiple software modules based on extraction and composition | |
| WO2006043012A1 (en) | Data processing system and method | |
| Jahnke et al. | Rewriting poor design patterns by good design patterns | |
| Koskimies | Object-orientation in attribute grammars | |
| Klare | Designing a Change-Driven Language for Model Consistency Repair Routines | |
| US7512899B1 (en) | Method and apparatus for a unified user interface | |
| Barghouti et al. | Implementation of a knowledge-based programming environment | |
| DeLine et al. | Lessons on converting batch systems to support interaction: Experience report | |
| WO1994004988A1 (en) | Extensible framework for constructing graphical applications | |
| O’Mullane et al. | Java coding standard and guidelines for dpac |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| FZDE | Dead |