Connect public, paid and private patent data with Google Patents Public Datasets

Reusing an application object

Download PDF

Info

Publication number
US20060150147A1
US20060150147A1 US11321357 US32135705A US2006150147A1 US 20060150147 A1 US20060150147 A1 US 20060150147A1 US 11321357 US11321357 US 11321357 US 32135705 A US32135705 A US 32135705A US 2006150147 A1 US2006150147 A1 US 2006150147A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
object
application
reference
program
part
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
Application number
US11321357
Inventor
Michiaki Tatsubori
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
International Business Machines Corp
Original Assignee
International Business Machines Corp
Priority date (The priority date 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 date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/50Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems
    • G06F21/51Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems at application loading time, e.g. accepting, rejecting, starting or inhibiting executable software based on integrity or source reliability
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F21/00Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/60Protecting data
    • G06F21/64Protecting data integrity, e.g. using checksums, certificates or signatures
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/30Creation or generation of source code
    • G06F8/36Software reuse

Abstract

The present invention provides methods, apparatus and systems for reusing an application object for use with an application program, in which the object can be reused without causing nonconformity in the consistency or security, even if the object to be reused is updated. An example of a method includes detecting that the application program ends referring to the application object, detecting that the application object is updated by the application program, deciding to reuse the application object in response to detecting no update of the application object, making the application object reusable in response to the end of referring to the object, and decision to reuse the application object.

Description

    FIELD OF THE INVENTION
  • [0001]
    The present invention relates to a method for reusing an application object generated upon a request for a structured composition from an application program, for example. More particularly, the invention relates to a method for reusing an application object for use with one or more application programs under the control of software such as middle-ware.
  • BACKGROUND ART
  • [0002]
    Structured compositions are used for describing information. An object provided with a structure such as DOM (Document Object Model), SDO (Service Data Object) or Bean is generated for the structured composition and communicated to an application program. Here, the application program often requires reusing an application object (hereinafter referred to an “object”) generated once.
  • [0003]
    A programming technique for caching an object, which is generated once, in order to achieve the abovementioned reuse of an object is also known as a Flyweight pattern. This technique does not repeatedly generate an object in response to each request from an application program but saves the object and returns it to the application program instead.
  • [0004]
    The following document is considered:
  • [0005]
    [Patent Document 1] Japanese Patent Laid-Open No. 2004-62716
  • [0006]
    As an advanced technique to the Flyweight pattern, a technique of caching DOM that is the result of an XML structure analysis (for example Patent Document 1). In this technique, a cached object is only reused for reading. In other words, an object cached at an application server is reused only for reading.
  • [0007]
    Problems to be Solved by the Invention
  • [0008]
    However, in the technique described in Patent Document 1, a cached object is unable to be partly updated and reused. A once-generated object not only needs to be used as it is without a change but also to be reused with a partial update. The technique described in Patent Document 1 does not work to reuse an object in the latter occasion.
  • [0009]
    If an application program requires to update a reusing object and the object is updated, an object different from an originally generated one is cached with a possibility of causing nonconformity in the consistency or security of the objects. That is to say, if an object, which is saved and referenced to by an application program A, is reused and updated in response to a request from another application program B, the application program A will use the structure or value of the object without knowledge of its update. This causes nonconformity in the consistency or security of the object.
  • SUMMARY OF THE INVENTION
  • [0010]
    Therefore, an aspect of the present invention is to provide a method for reusing an application object for use with an application program, in which the object can be reused without causing nonconformity in the consistency or security, even if the object to be reused is updated.
  • [0011]
    The abovementioned problem is solved by the present invention which provides a method for reusing an application object for use with an application program, including: a reference detection step of detecting that said application program ends referring to said application object; an update detection step of detecting that said application object is updated by said application program; a reuse decision step of deciding to reuse said application object in response to detecting no update of said application object; and a reusing step of making said application object reusable in response to the end of referring to said object, and decision to reuse said application object.
  • [0012]
    Additionally, the present invention also makes the application object reusable by storing information on the location where the application object is stored (reference). Accordingly, with the present invention, since information on a reusable part of an object (reference) instead of the object to be reused itself is cached, an overhead due to caching is small.
  • [0013]
    Accordingly, with the present invention, since it is determined whether or not to reuse an object of one application program in response to the end of referring to the object and detecting no update of the object, it is possible to reuse the object without causing nonconformity in the consistency or security, even if the object to be reused is updated.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0014]
    For a more complete understanding of the present invention and the advantage thereof, reference is now made to the following description taken in conjunction with the accompanying drawings, in which:
  • [0015]
    FIG. 1 is a diagram illustrating a hardware configuration of the information processing unit 1;
  • [0016]
    FIG. 2 is a flowchart showing operations performed by the information processing unit 1, which is an example of the present invention;
  • [0017]
    FIG. 3 is a flowchart showing operations performed by the information processing unit 1, which is an example of the present invention;
  • [0018]
    FIG. 4 is a flowchart showing operations performed by the information processing unit 1, which is an example of the present invention;
  • [0019]
    FIG. 5 is a flowchart showing operations performed by the information processing unit 1, which is an example of the present invention;
  • [0020]
    FIG. 6 shows an example of a method for performing an update to DOM, which is an example of the present invention;
  • [0021]
    FIG. 7 shows an example of a method for making an update to SDO, which is an example of the present invention; and
  • [0022]
    FIG. 8 illustrates a hardware configuration a computer used as the information processing unit 1, which is an example of the present invention.
  • DESCRIPTION OF SYMBOLS
  • [0023]
    1 . . . information processing unit
  • [0024]
    10 . . . controlling part
  • [0025]
    11 . . . reference detecting part
  • [0026]
    12 . . . update detecting part
  • [0027]
    13 . . . reuse decision part
  • [0028]
    14 . . . reuse part
  • [0029]
    20 . . . inputting part
  • [0030]
    30 . . . outputting part
  • [0031]
    40 . . . storing part
  • [0032]
    41 . . . reference storing part
  • [0033]
    42 . . . reference candidate storing part
  • [0034]
    45 . . . buffer part
  • DETAILED DESCRIPTION OF THE INVENTION
  • [0035]
    The present invention provides methods for reusing an application object for use with an application program, in which the object can be reused without causing nonconformity in the consistency or security, even if the object to be reused is updated.
  • [0036]
    An embodiment of the present invention solves the abovementioned problems, following a dedicated study by providing a method for reusing an application object for use with an application program, including: a reference detection step of detecting that said application program ends referring to said application object; an update detection step of detecting that said application object is updated by said application program; a reuse decision step of deciding to reuse said application object in response to detecting no update of said application object; and a reusing step of making said application object reusable in response to the end of referring to said object, and decision to reuse said application object.
  • [0037]
    Thus, according to the present invention, it is detected that an application program ends referring to an application object, it is detected that the application object is updated by the application object, the application object is decided to be reused in response to detecting no update of the application object, the application object is made reusable in response to the end of referring to the object, and decision to reuse the application object.
  • [0038]
    Also, according to the present invention, since it is decided to reuse an object of one application program in response to the end of referring to the object and detecting no update of the object, it is possible to reuse the object without causing nonconformity in the consistency or security, even if the object to be reused is updated.
  • [0039]
    More specifically, in addition to the abovementioned configuration, the present invention also makes the application object reusable by storing information on the location where the application object is stored (reference). Accordingly, with the present invention, since information on a reusable part of an object (reference) instead of the object to be reused itself is cached, an overhead due to caching is small.
  • [0040]
    Accordingly, with the present invention, since it is determined whether or not to reuse an object of one application program in response to the end of referring to the object and detecting no update of the object, it is possible to reuse the object without causing nonconformity in the consistency or security, even if the object to be reused is updated.
  • [0041]
    Advantageous embodiments of the present invention will be described with reference to the drawings. As shown in FIG. 1, an information processing unit 1 includes a controlling part 10 for controlling application programs and data, and a storing part 40 for storing application programs and application objects (hereinafter simply referred to “objects”). The information processing unit 1 may further include an inputting part 20 for accepting inputs from a user and an outputting part 30 for outputting a result of an operation of an application program.
  • [0042]
    The information processing unit 1 is a device with a function of processing information and may be a computer. In the information processing unit 1, an application program and software (middleware) which works between the application program and OS (Operating System) operate.
  • [0043]
    The controlling part 10 is a central processing unit responsible for calculating and controlling application programs, objects, middleware and the like, which operates in the information processing unit 1 and may be a CPU (Central Processing Unit). The controlling part 10 includes a reference detecting part 11, an update detecting part 12, a reuse decision part 13 and a reuse part 14.
  • [0044]
    The reference detecting part 11 monitors an application program that is referring to an object and detects the end of the reference. The update detecting part 12 detects that an application program is going to update an object. The reuse decision part decides to reuse an object.
  • [0045]
    The reuse part 14 makes the object generated by an application reusable. The reuse part 14 makes the object reusable by storing information on a reusable part of the object (reference). The reuse part makes the object reusable by copying the object to be updated and storing the reference for the copied object in response to the detection that the object is to be updated.
  • [0046]
    The storing part 40 stores an OS, middleware, application programs, objects, references for the objects and the like of the information processing unit 1. That is to say, the storing part 40 stores programs and data to be handled in the information processing unit 1. For example, the storing part 40 may be memory or a hard disk of a computer. The storing part 40 may include a reference storing part 41, a reference candidate storing part 42 and a buffer part 45.
  • [0047]
    The reference storing part 41 stores a reference for an object which is made reusable. A reference is information on the location where an object is stored. The reference is made when an object is generated. A reference is an address or a pointer to indicate the location where an object is saved. The reference candidate storing part 42 stores a reference for a candidate for reusable object. The buffer part 45 stores an application program or an object itself. The buffer part 45 provides storage called “heap area” in Java® (registered trademark) language.
  • [0048]
    Next, a specific operation performed by the information processing unit 1 will be described with reference to the flowchart in FIG. 2.
  • [0049]
    First, an application program A, which is one application program operating in the information processing unit 1, requests an object A, which is one object (step S01). If the object A is requested by an application program for the first time, the object A is generated in response to the request for the first time and a reference for the object A is given at this time of generation (step S02). The application program uses the object A on the basis of the reference. If the information processing unit 1 does not detect that the application program updates the object A when it uses the object A (step S03), the information processing unit 1 causes the reference storing part 41 to store the reference when the application program A finishes the reference (step S05). If the information processing unit 1 detects that the application program updates the object, it updates the object without storing the reference (step S04).
  • [0050]
    Then, the process enters the reusing step. The application program A or an application program B, which is different from the application program A, requests the object A (step S06). As the object A is already generated, it is determined whether or not to reuse the object A. If the reference for the object A is present in the reference storing part 41 (step S07), the information processing unit 1 makes the object A to be reused by returning the stored reference to the application program B (step S09). If the reference for the object A is not present in the reference storing part 41 (step S07), the object A is generated and the reference for the object A is given (step S08).
  • [0051]
    The operation of the present invention will be described in further detail. FIGS. 3, 4 and 5 are flowcharts illustrating that the present invention reuses an object by using the reference candidate storing part 42. First, the steps of retrieving a reference from the reference storing part 41 and storing the reference in the reference candidate storing part 42 will be described with reference to FIG. 3.
  • [0052]
    First, the controlling part 10 accepts a request for an object from an application program (step S11). Next, the reuse decision part 13 checks whether the reference for the requested object is stored in the reference storing part 41 (step S12). If the reference is stored in the reference storing part 41, the reuse part 14 retrieves the reference for the object from the reference storing part 41 (step S14) and stores the reference in the reference candidate storing part 42 (step S15). The retrieval at step S14 means that a reference is temporally cached in the buffer part 45 without left in the reference storing part 41.
  • [0053]
    If the reference for the requested object is not stored in the reference storing part 41, the reuse part 14 generates the requested object and obtains a reference (step S13), and stores the reference in the reference candidate storing part 42 (step S15). Finally, the reference for the object is returned to the application program (step S16).
  • [0054]
    Now, a flow of detecting the end of reference by an application program will be described with reference to FIG. 4.
  • [0055]
    The reference detecting part 11 detects the end of reference to an object by an application program (step S21). If it detects the end, the reference for the object is checked whether or not being stored in the reference candidate storing part 42 (step S22). If the reference is stored in the reference candidate storing part 42, the reference for the object is retrieved from the reference candidate storing part 42 (step S24) and stored in the reference storing part 41 (step S25). The retrieval at step S24 means that a reference is temporally cached in the buffer part 45 without left in the reference candidate storing part 42. If the reference is not stored in the reference candidate storing part 42, the object is discarded (deleted) (step S23). The situation of an object being not stored in the reference candidate storing part 42 means that the object is updated (to be described with reference to FIG. 5).
  • [0056]
    Now, processes performed when the operation to update an object is detected will be described with reference to FIG. 5.
  • [0057]
    When an application program is operating to update an object, the update detecting part 12 detects that the object is to be updated before it is actually updated (step S31). The reuse decision part 13 checks whether or not the reference for the object is stored in the reference candidate storing part 42 (step 32). The reference for the object is retrieved from the reference candidate storing part 42 (step S33). The retrieval at step S33 means that a reference is temporally cached in the buffer part 45 without left in the reference storing part 42. Next, the reuse part 14 copies (caches) the object (step S34) and stores the reference for the copied object in the reference storing part 41 (step S35). Then the updating operation to the object is performed (step S36).
  • [0058]
    As the reuse part 14 copies the object and stores the reference for the object before the object is actually updated, the update causes no problem in consistency and security of the object values or the like when the object and reference to be updated are used.
  • [0059]
    More specific example will be described below.
  • [0060]
    [Reference Management]
  • [0061]
    In order to detect that an application program ends referring to an object, the abovementioned reference detecting part 11 may use any one of or a combination of four approaches below.
  • [0062]
    1) An approach by using a finalizer mechanism
  • [0063]
    With this approach, the reference detecting part 11 detects that a reference to an object ends by using a mechanism, such as finalize ( ) in Java® language, which is invoked before the object is collected. It informs the application program of the fact with the object being revivable. A new object with a special finalizer is linked from the object in order to make the object revivable. (The link is made from a component of objects, which causes nonconformity when the reference is kept, or a component, which is referring the object. For example, the link needs to be made only from Document object in the case of DOM.) Given that the class of the object with a special finalizer is Resurrection, its implementation will be as below.
    TABLE 1
    class Document {
     Resurrection resurrector = reference to an Resurrection object;}
    class Resurrection {
     Document resurrectee = reference to an object, which is a candidate
    for reuse;
     void finalize ( ) {
     if (the object is a candidate for reuse) {input the reference for
    the object in the reference storing part}
           }
          }
  • [0064]
    2) An approach of tracing (tracking) a link from a field of an application object
  • [0065]
    With this approach, a technique generally used in a garbage collection is implemented as middleware by using a reflection mechanism or the like. The reference detecting part 11 traces a reference from a field of an application program, and determines that no reference is made for an object. If the reference detecting part 11 is unable to confirm that no reference is made in this narrow-ranged tracing, it may stop the tracing and determine that the reference can be saved. In the case that the reference may be saved, the object will be given up for the reuse, or reference management by the abovementioned finalizer mechanism may be used.
  • [0066]
    3) An approach of cooperating with middleware, which controls the operation of an application program, based on information given from a user or an application program or information on examination of a code of an application program
  • [0067]
    With this approach, the reference detecting part 11 determines that an application program does not keep saving an object on the basis of information on a setting file. The reference detecting part 11 examines the application code and detects that the application program cannot continue to save the object. As middleware, which controls the operation of an application program, controls to start and end a process, which uses the object, the end of the process can be detected. In this case, that the application program is not saving the object, which is handed to the application program, can be detected with the end of the process.
  • [0068]
    The present invention can perform the examination of a code, for example, by applying an escape analysis (ACM, TOPLAS Vol. 25 Issue 6, p. 713-775) used for stack allocation or synchronization deletion. If an object remains linked directly or indirectly from a field in an application program or a reference for the object is outside the range for the analysis, it is determined that the object is possibly saved. In this case, the reference is not reused or reference management techniques described in 1) or 2) are used.
  • [0069]
    4) An approach of reusing an object for each thread on the basis of information given from a user or an application program or information on examination of a code of an application program
  • [0070]
    With this approach, the reference detecting part 11 reuses an object for each thread by using thread local variables or the like (without reusing an object across threads). When an object needs to be reused in the same thread after the object is given to an application program, the process, which uses the object before the object is given to the application program, assuredly finished and it is determined that the object is not saved by the application program. This is only the case when multiple objects are not used in a single process of an application program. Code examination is the same as that in 3).
  • [0071]
    The reference management will be described by using a finalizer mechanism along with a flow in FIG. 4.
  • [0072]
    1) When an object, which is reusable for representing a message accepted from an application program, is in the first step (when the object is used for the first time), the controlling part 10 generates an object anew as in a typical process.
  • [0073]
    2) The reuse part 14 stores a reference of an object to be given to the application program in the reference candidate storing part 42 and makes it revivable.
  • [0074]
    3) The controlling part 10 gives the generated object to the application program.
  • [0075]
    4) When the finalizer mechanism detects that the application program ends the reference to the given object, the reuse part 15 stores the reference for the object in the reference storing part 41.
  • [0076]
    5) As the reusable object is stored in the reference storing part 41, this object is reused and, if necessary, updated and made an object corresponding to the newly accepted message.
  • [0077]
    [Update Detection]
  • [0078]
    As an approach to detect that an application program updates an object, the update detecting part 12 may use either of or a combination of two approaches below.
  • [0079]
    1) An approach of monitoring invocation of a method for updating an object
  • [0080]
    With this approach, all the implementation of methods, which perform updates, among the methods of the object class is inserted with a code informing of the update. For example, in the case of Node class of DOM, appendChild( ) accompanies with an update to a DOM tree, which is the object of method invocation, and a DOM tree, to which a node given by an argument is attributed. The implementation is as below.
    TABLE 2
    Node appendChild (Node newChild) {
     ((DocumentImpl) this.getDocument ( )). invalidate( );
     ((DocumentImpl) newChild.getDocument( )). invalidate ( );
     the original code of appendChild ( )
    }
  • [0081]
    “DocumentImpl” is a subclass of Document class, which represents the entire document, and implementation of Document class provided by API (Application Interface). “invalidate( )” invoked for this class implements an algorithm “when an update is detected” shown below.
  • [0082]
    2) An approach of disabling use of a method for performing an update on the basis of information given by a user or an application program or information on examination of a code of an application program
  • [0083]
    This approach specifies that an application program does not update an object with a setting file or detects that a method for updating an object is not invoked is detected by examining an application code. All the implementation of methods, perform updates, among the methods of the object class is inserted with a code for issuing an exception.
  • [0084]
    Code examination can be achieved by applying an escape analysis used in stack allocation or synchronization deletion. If an object remains linked directly or indirectly from a field in an application program or a reference for the object is outside the range for the analysis, it is determined that the object is possibly updated. If the object is possibly updated, the object is copied instead of reused or an update detection approach described in 1) is used. If an update to the object is detected with the approach described in 1), reuse of the object is simply disabled or the object is copied before the update for future reuse.
  • [0085]
    FIG. 6 shows an example of a method for performing an update to DOM. For the methods shown in FIG. 6, codes to inform of the invocation are inserted. The codes, such as an attribute value or a text element, which are known to be reset when they are reused and which cause no problem even after an update is made can be omitted.
  • [0086]
    The SDO (Service Data Object) is used for representing an object such as a parameter or a returning value of a service for Web Service. FIG. 7 shows an example of a method for making an update to SDO. For the methods shown here, codes to inform of the invocation are inserted. The Bean is an object specific to an application program, which is used for representing an object such as a parameter or a returning value of a service for Web Service. Although the method, which is updated in Bean, differs for each application program, a method, called setter method, which is used for updating the Bean, can be identified from a method name (start with set) and meta-information called Bean Info. For setter methods, codes to inform of the invocation are inserted. As the Bean implementation is usually generated by using a development environment provided as a set with an application server, a method used for updating Bean can be identified by making the generation tool to generate the setter method with an information code inserted.
  • [0087]
    Update detection will be described more specifically along with a flow in FIG. 5.
  • [0088]
    1) As an object reusable for representing a message accepted from an application program does not exist at the first step, a new object is generated as in the typical process.
  • [0089]
    2) The reuse part 14 stores a reference for an object to be given to the application program in the reference candidate storing part 42 and make it revivable.
  • [0090]
    3) The controlling part 10 gives a generated object to the application program.
  • [0091]
    4) When the update detecting part 12 detects that an application program is to update an object, it retrieves the reference for the object from the reference candidate storing part 42.
  • [0092]
    5) The reuse part 14 copies the object to be updated and stores the object in the buffer part 45 and stores the reference for the object in the reference storing part 41.
  • [0093]
    6) The controlling part 10 performs the actual updating.
  • [0094]
    7) As an object reusable for representing the next accepted message is stored in the reference storing part 41, this object is reused and, if needed, updated and made as an object corresponding to a message accepted anew.
  • [0095]
    The information processing unit 1 may include a CPU (Central Processing Unit) 80, a host controller 81, an I/O controller 82, RAM (Random Access Memory) 83, ROM (Read Only Memory) 84, a hard disk drive 85, a DVD/CD-ROM drive 86, an FD drive 87, an input device 88, which is a mouse, a keyboard or the like for accepting inputs from a user, as an inputting part 20, a display device 90 as an outputting part 30 and a communication interface 91 as shown in FIG. 8, for example.
  • [0096]
    An information processing unit for implementing the embodiment and a method for reusing an object can be implemented by a program executed at a computer or a server. Storage media for this program include an optical storage medium, a tape medium and semiconductor memory. A storage device, such as a hard disk or RAM, which is provided in a server system connected to a private communication network or the Internet, may be used as a storage medium for providing a program over the network.
  • [0097]
    Although the embodiment of the present invention has been described above, it simply exemplifies a specific example and does not limit the present invention. The effects described in the description of the embodiment of the present invention are simple listing of the most advantageous effects of the present invention and they don't limit the effect of the present invention.
  • [0098]
    Advantages of the invention include that the present invention is applicable to software used as middleware, further applicable to an XML purser or the like. Objects to be applied with the present invention may be SAAJ (SOAP with Attachments API for Java®) object.
  • [0099]
    Variations described for the present invention can be realized in any combination desirable for each particular application. Thus particular limitations, and/or embodiment enhancements described herein, which may have particular advantages to a particular application need not be used for all applications. Also, not all limitations need be implemented in methods, systems and/or apparatus including one or more concepts of the present invention. Methods may be implemented as signal methods employing signals to implement one or more steps. Signals include those emanating from the Internet, etc.
  • [0100]
    The present invention can be realized in hardware, software, or a combination of hardware and software. A visualization tool according to the present invention can be realized in a centralized fashion in one computer system, or in a distributed fashion where different elements are spread across several interconnected computer systems. Any kind of computer system—or other apparatus adapted for carrying out the methods and/or functions described herein—is suitable. A typical combination of hardware and software could be a general purpose computer system with a computer program that, when being loaded and executed, controls the computer system such that it carries out the methods described herein. The present invention can also be embedded in a computer program product, which comprises all the features enabling the implementation of the methods described herein, and which—when loaded in a computer system—is able to carry out these methods.
  • [0101]
    Computer program means or computer program in the present context include any expression, in any language, code or notation, of a set of instructions intended to cause a system having an information processing capability to perform a particular function either directly or after conversion to another language, code or notation, and/or reproduction in a different material form.
  • [0102]
    Thus the invention includes an article of manufacture which comprises a computer usable medium having computer readable program code means embodied therein for causing a function described above. The computer readable program code means in the article of manufacture comprises computer readable program code means for causing a computer to effect the steps of a method of this invention. Similarly, the present invention may be implemented as a computer program product comprising a computer usable medium having computer readable program code means embodied therein for causing a a function described above. The computer readable program code means in the computer program product comprising computer readable program code means for causing a computer to effect one or more functions of this invention. Furthermore, the present invention may be implemented as a program storage device readable by machine, tangibly embodying a program of instructions executable by the machine to perform method steps for causing one or more functions of this invention.
  • [0103]
    It is noted that the foregoing has outlined some of the more pertinent objects and embodiments of the present invention. This invention may be used for many applications. Thus, although the description is made for particular arrangements and methods, the intent and concept of the invention is suitable and applicable to other arrangements and applications. It will be clear to those skilled in the art that modifications to the disclosed embodiments can be effected without departing from the spirit and scope of the invention. The described embodiments ought to be construed to be merely illustrative of some of the more prominent features and applications of the invention. Other beneficial results can be realized by applying the disclosed invention in a different manner or modifying the invention in ways known to those familiar with the art.

Claims (20)

1) A method for reusing an application object for use with an application program, comprising:
a reference detection step of detecting that said application program ends referring to said application object;
an update detection step of detecting that said application object is updated by said application program;
a reuse decision step of deciding to reuse said application object in response to detecting no update of said application object; and
a reusing step of making said application object reusable in response to an end of referring to said object and a decision to reuse said application object.
2) The method according to claim 1, wherein said reusing step makes said application object reusable by storing information on a location where said application object is stored.
3) The method according to claim 2, wherein said reusing step makes said application object reusable by copying the object to be updated and storing a reference for a copied application object in response to the detection that said application object is to be updated.
4) The method according to claim 2, wherein said reference detecting step detects the end of said reference by detecting that a reference from said application program ends by using a finalize method in Java® language.
5) The method according to claim 2, wherein said reference detecting step detects the end of said reference by detecting that a reference from said application program ends on a basis of a command indicating that said application program is to reference.
6) The method according to claim 2, wherein said reference detecting step detects the end of said reference by detecting that a reference from said application program ends by dynamically tracing a link to an object from an application program.
7) The method according to claim 2, wherein said reference detecting step detects the end of said reference by detecting that a reference from said application program ends on a basis of information on a setting file.
8) The method according to claim 2, wherein said reference detecting step detects the end of said reference by detecting that a reference from said application program ends on a basis of a thread of said application program.
9) The method according to claim 1, wherein said update detection step detects that said application object is to be updated by said application program from a method, which is updated by said application program.
10) The method according to claim 1, wherein said update detection step detects that said application object is to be updated by said application program from information on examination of a code.
11) The method according to claim 1, wherein said update detection step detects that said application object is to be updated by said application program from information on a setting file.
12) The method according to claim 1, wherein said update detection step detects that said application object is to be updated by said application program by detecting one of: a method of DOM; a method of SDO; and a method of Bean.
13) An article of manufacture comprising a computer usable medium having computer readable program code means embodied therein for causing reuse of an application object for use with an application program], the computer readable program code means in said article of manufacture comprising computer readable program code means for causing a computer to effect the steps of claim 1.
14) The method according to claim 1, wherein:
said reusing step makes said application object reusable by one of: storing information on a location where said application object is stored; copying the object to be updated and storing a reference for a copied application object in response to the detection that said application object is to be updated.
said reference detecting step detects the end of said reference by detecting one of: that a reference from said application program ends by using a finalize method in Java® language; that a reference from said application program ends on a basis of a command indicating that said application program is to reference; that a reference from said application program ends by dynamically tracing a link to an object from an application program; that a reference from said application program ends on a basis of information on a setting file; and that a reference from said application program ends on a basis of a thread of said application program;
said update detection step detects that said application object is to be updated by said application program from one of: a method, which is updated by said application program; information on examination of a code; and from information on a setting file.
15) A computer program for reusing an application object for use with an application program, comprising:
a function of enabling said application program to detect an end of referring to said application object;
a function of detecting that said application object is changed by said application program;
a function of deciding to reuse said application object in response to detecting no change of said application object; and
a function of making said application object reusable in response to the end of referring to said object and decision of reusing said application object.
16) An information processing apparatus for reusing an application object for use with an application program, comprising:
a reference detection part of enabling said application program to detect an end of referring to said application object;
a change detection part of detecting that said application object is changed by said application program;
a reuse decision part of deciding to reuse said application object in response to detecting no change of said application object; and
a reuse part of making said application object reusable in response to the end of referring to said object and decision of reusing said application object.
17) The information processing unit according to claim 16, wherein said reuse part makes said application object reusable by storing information on a reusable part of said application object.
18) The information processing unit according to claim 17, wherein said reusing part makes said application object reusable by copying an object to be updated and storing a reference for the copied application object in response to the detection that said application object is to be updated.
19) A computer program product comprising a computer usable medium having computer readable program code means embodied therein for causing reuse of an application object for use with an application program, the computer readable program code means in said computer program product comprising computer readable program code means for causing a computer to effect the functions of claim 16.
20) A program storage device readable by machine, tangibly embodying a program of instructions executable by the machine to perform method steps for reusing an application object for use with an application program, said method steps comprising the steps of claim 1.
US11321357 2004-12-28 2005-12-28 Reusing an application object Abandoned US20060150147A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
JP2004-380299 2004-12-28
JP2004380299A JP4144885B2 (en) 2004-12-28 2004-12-28 Re-use method of application objects

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US12169397 US8438557B2 (en) 2004-12-28 2008-07-08 Reusing an application object

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US12169397 Continuation US8438557B2 (en) 2004-12-28 2008-07-08 Reusing an application object

Publications (1)

Publication Number Publication Date
US20060150147A1 true true US20060150147A1 (en) 2006-07-06

Family

ID=36642160

Family Applications (2)

Application Number Title Priority Date Filing Date
US11321357 Abandoned US20060150147A1 (en) 2004-12-28 2005-12-28 Reusing an application object
US12169397 Expired - Fee Related US8438557B2 (en) 2004-12-28 2008-07-08 Reusing an application object

Family Applications After (1)

Application Number Title Priority Date Filing Date
US12169397 Expired - Fee Related US8438557B2 (en) 2004-12-28 2008-07-08 Reusing an application object

Country Status (2)

Country Link
US (2) US20060150147A1 (en)
JP (1) JP4144885B2 (en)

Cited By (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080127215A1 (en) * 2006-08-10 2008-05-29 Mitsubishi Electric Corporation Software creating method
US20080162684A1 (en) * 2006-12-27 2008-07-03 Ryoh Neyama Apparatus and Method For Backing Up Data On Server Using At Least One Cache As A Client
US20090064039A1 (en) * 2007-09-04 2009-03-05 Apple Inc. List item layouts system and method
US20110022943A1 (en) * 2009-07-23 2011-01-27 International Business Machines Corporation Document object model (dom) application framework
US20130239029A1 (en) * 2008-05-08 2013-09-12 Salesforce.Com, Inc System, method and computer program product for creating a re-usable component utilizing a multi-tenant on-demand database service
CN104317673A (en) * 2014-10-24 2015-01-28 新华瑞德(北京)网络科技有限公司 Program recycling method and device and recovering method and device

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP5511134B2 (en) * 2007-12-27 2014-06-04 株式会社エクサ Object cache construction method, the object cache construction program
JP6251158B2 (en) * 2014-12-12 2017-12-20 Tis株式会社 Program conversion system

Citations (21)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4797810A (en) * 1986-06-26 1989-01-10 Texas Instruments Incorporated Incremental, multi-area, generational, copying garbage collector for use in a virtual address space
US5187786A (en) * 1991-04-05 1993-02-16 Sun Microsystems, Inc. Method for apparatus for implementing a class hierarchy of objects in a hierarchical file system
US5274804A (en) * 1991-11-20 1993-12-28 Parcplace Systems Automatic storage-reclamation postmortem finalization process
US5392432A (en) * 1991-08-27 1995-02-21 At&T Corp. Method for automatic system resource reclamation for object-oriented systems with real-time constraints
US5481718A (en) * 1993-05-21 1996-01-02 Fujitsu Limited Object-oriented system having object models containing plural objects with instantiation following static classification by class relationships, dynamic classification by temporal instantiation, and causality restrictions
US6049838A (en) * 1996-07-01 2000-04-11 Sun Microsystems, Inc. Persistent distributed capabilities
US6066181A (en) * 1997-12-08 2000-05-23 Analysis & Technology, Inc. Java native interface code generator
US20020023113A1 (en) * 2000-08-18 2002-02-21 Jeff Hsing Remote document updating system using XML and DOM
US6408434B1 (en) * 1999-01-07 2002-06-18 Sony Corporation System and method for using a substitute directory to automatically install an update program
US6438560B1 (en) * 1999-09-16 2002-08-20 International Business Machines Corporation Reuse of immutable objects during object creation
US6463470B1 (en) * 1998-10-26 2002-10-08 Cisco Technology, Inc. Method and apparatus of storing policies for policy-based management of quality of service treatments of network data traffic flows
US20020165870A1 (en) * 2001-03-01 2002-11-07 Krishnendu Chakraborty Method and apparatus for freeing memory from an extensible markup language document object model tree active in an application cache
US20030028683A1 (en) * 2001-08-01 2003-02-06 Yorke Gordon James Method and system for object cache synchronization
US20030221022A1 (en) * 2002-05-08 2003-11-27 Harlan Sexton Method for performing data migration
US6678882B1 (en) * 1999-06-30 2004-01-13 Qwest Communications International Inc. Collaborative model for software systems with synchronization submodel with merge feature, automatic conflict resolution and isolation of potential changes for reuse
US20060090164A1 (en) * 2004-10-05 2006-04-27 Microsoft Corporation Object cloning for demand events
US20060101446A1 (en) * 2004-10-18 2006-05-11 Microsoft Corporation System and method for sharing objects between applications in a virtual runtime environment
US20060122971A1 (en) * 2004-12-02 2006-06-08 International Business Machines Corporation Method and apparatus for generating a service data object based service pattern for an enterprise java beans model
US7287256B1 (en) * 2003-03-28 2007-10-23 Adobe Systems Incorporated Shared persistent objects
US20080066081A1 (en) * 2003-10-21 2008-03-13 Gemstone Systems, Inc. Object monitoring system in shared object space
US7421458B1 (en) * 2003-10-16 2008-09-02 Informatica Corporation Querying, versioning, and dynamic deployment of database objects

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6256712B1 (en) * 1997-08-01 2001-07-03 International Business Machines Corporation Scaleable method for maintaining and making consistent updates to caches
US6202208B1 (en) * 1998-09-29 2001-03-13 Nortel Networks Limited Patching environment for modifying a Java virtual machine and method
JP4180247B2 (en) 2000-04-28 2008-11-12 富士通株式会社 Apparatus and method switches the object management method
JP3907187B2 (en) 2002-07-31 2007-04-18 インターナショナル・ビジネス・マシーンズ・コーポレーションInternational Business Maschines Corporation Sax parser, a method for the sax parser, and program

Patent Citations (21)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4797810A (en) * 1986-06-26 1989-01-10 Texas Instruments Incorporated Incremental, multi-area, generational, copying garbage collector for use in a virtual address space
US5187786A (en) * 1991-04-05 1993-02-16 Sun Microsystems, Inc. Method for apparatus for implementing a class hierarchy of objects in a hierarchical file system
US5392432A (en) * 1991-08-27 1995-02-21 At&T Corp. Method for automatic system resource reclamation for object-oriented systems with real-time constraints
US5274804A (en) * 1991-11-20 1993-12-28 Parcplace Systems Automatic storage-reclamation postmortem finalization process
US5481718A (en) * 1993-05-21 1996-01-02 Fujitsu Limited Object-oriented system having object models containing plural objects with instantiation following static classification by class relationships, dynamic classification by temporal instantiation, and causality restrictions
US6049838A (en) * 1996-07-01 2000-04-11 Sun Microsystems, Inc. Persistent distributed capabilities
US6066181A (en) * 1997-12-08 2000-05-23 Analysis & Technology, Inc. Java native interface code generator
US6463470B1 (en) * 1998-10-26 2002-10-08 Cisco Technology, Inc. Method and apparatus of storing policies for policy-based management of quality of service treatments of network data traffic flows
US6408434B1 (en) * 1999-01-07 2002-06-18 Sony Corporation System and method for using a substitute directory to automatically install an update program
US6678882B1 (en) * 1999-06-30 2004-01-13 Qwest Communications International Inc. Collaborative model for software systems with synchronization submodel with merge feature, automatic conflict resolution and isolation of potential changes for reuse
US6438560B1 (en) * 1999-09-16 2002-08-20 International Business Machines Corporation Reuse of immutable objects during object creation
US20020023113A1 (en) * 2000-08-18 2002-02-21 Jeff Hsing Remote document updating system using XML and DOM
US20020165870A1 (en) * 2001-03-01 2002-11-07 Krishnendu Chakraborty Method and apparatus for freeing memory from an extensible markup language document object model tree active in an application cache
US20030028683A1 (en) * 2001-08-01 2003-02-06 Yorke Gordon James Method and system for object cache synchronization
US20030221022A1 (en) * 2002-05-08 2003-11-27 Harlan Sexton Method for performing data migration
US7287256B1 (en) * 2003-03-28 2007-10-23 Adobe Systems Incorporated Shared persistent objects
US7421458B1 (en) * 2003-10-16 2008-09-02 Informatica Corporation Querying, versioning, and dynamic deployment of database objects
US20080066081A1 (en) * 2003-10-21 2008-03-13 Gemstone Systems, Inc. Object monitoring system in shared object space
US20060090164A1 (en) * 2004-10-05 2006-04-27 Microsoft Corporation Object cloning for demand events
US20060101446A1 (en) * 2004-10-18 2006-05-11 Microsoft Corporation System and method for sharing objects between applications in a virtual runtime environment
US20060122971A1 (en) * 2004-12-02 2006-06-08 International Business Machines Corporation Method and apparatus for generating a service data object based service pattern for an enterprise java beans model

Cited By (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080127215A1 (en) * 2006-08-10 2008-05-29 Mitsubishi Electric Corporation Software creating method
US20080162684A1 (en) * 2006-12-27 2008-07-03 Ryoh Neyama Apparatus and Method For Backing Up Data On Server Using At Least One Cache As A Client
US7870422B2 (en) * 2006-12-27 2011-01-11 International Business Machines Corporation Apparatus and method for backing up data on server using at least one cache as a client
US20090064039A1 (en) * 2007-09-04 2009-03-05 Apple Inc. List item layouts system and method
US20100251178A1 (en) * 2007-09-04 2010-09-30 Apple Inc. List item layouts system and method
US7810047B2 (en) * 2007-09-04 2010-10-05 Apple Inc. List item layouts system and method
US20130239029A1 (en) * 2008-05-08 2013-09-12 Salesforce.Com, Inc System, method and computer program product for creating a re-usable component utilizing a multi-tenant on-demand database service
US9791993B2 (en) * 2008-05-08 2017-10-17 Salesforce.Com, Inc System, method and computer program product for creating a re-usable component utilizing a multi-tenant on-demand database service
US20110022943A1 (en) * 2009-07-23 2011-01-27 International Business Machines Corporation Document object model (dom) application framework
CN104317673A (en) * 2014-10-24 2015-01-28 新华瑞德(北京)网络科技有限公司 Program recycling method and device and recovering method and device

Also Published As

Publication number Publication date Type
JP4144885B2 (en) 2008-09-03 grant
JP2006185325A (en) 2006-07-13 application
US20090049426A1 (en) 2009-02-19 application
US8438557B2 (en) 2013-05-07 grant

Similar Documents

Publication Publication Date Title
US6539501B1 (en) Method, system, and program for logging statements to monitor execution of a program
US6182083B1 (en) Method and system for multi-entry and multi-template matching in a database
US6083281A (en) Process and apparatus for tracing software entities in a distributed system
US6651183B1 (en) Technique for referencing failure information representative of multiple related failures in a distributed computing environment
US6317818B1 (en) Pre-fetching of pages prior to a hard page fault sequence
US7302608B1 (en) Systems and methods for automatic repair and replacement of networked machines
US7506336B1 (en) System and methods for version compatibility checking
US20050028143A1 (en) Automated semantic-based updates to modified code base
US6314567B1 (en) Apparatus and method for transferring state data when performing on-line replacement of a running program code and data
US5829022A (en) Method and apparatus for managing coherency in object and page caches
US20090094609A1 (en) Dynamically providing a localized user interface language resource
US7624394B1 (en) Software installation verification
US20110283264A1 (en) Detection of method calls to streamline diagnosis of custom code through dynamic instrumentation
US20060271557A1 (en) Database Caching and Invalidation Based on Detected Database Updates
US20080320282A1 (en) Method And Systems For Providing Transaction Support For Executable Program Components
US6269442B1 (en) Apparatus and method for on-line replacement of a running program code and data using checkpoints
US20130013653A1 (en) Tracking file contents
US6314460B1 (en) Method and apparatus for analyzing a storage network based on incomplete information from multiple respective controllers
US6816874B1 (en) Method, system, and program for accessing performance data
US20020091712A1 (en) Data-base caching system and method of operation
US7058667B2 (en) Method and system for creating and maintaining version-specific properties in a file
US6681386B1 (en) Method, system, and program for parameter expansion, generation, and execution of scripts in a networked environment
US6289375B1 (en) Method and apparatus for invoking network agent functions using a hash table
US6253240B1 (en) Method for producing a coherent view of storage network by a storage network manager using data storage device configuration obtained from data storage devices
Stojanovic et al. Ontology Evolution within Ontology Editors.

Legal Events

Date Code Title Description
AS Assignment

Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:TATSUBORI, MICHIAKI;REEL/FRAME:017287/0892

Effective date: 20060126