Repository relationship programming

• US 8,601,455 B2
• Filed: 06/27/2011
• Issued: 12/03/2013
• Est. Priority Date: 09/30/2004
• Status: Active Grant

• Current Assignee: Kevin P. Graham
• Original Assignee: Kevin P. Graham
• Inventors: Graham, Kevin P.
• Primary Examiner(s): Dam, Tuan Q.
• Assistant Examiner(s): Wei, Zheng
• Application Number:
  US13/169,969
• Publication Number:
  US 20120005654A1
• Time in Patent Office: 890 Days
• Field of Search: None
• US Class Current: 717/151
• CPC Class Codes: G06F 8/36 Software reuse

Abstract

Embodiments of systems, methods and computer program products are described for implementing repository relationship programming. Implementations described herein describe processes for implementing a union of concerns, integrating concerns, assembling concerns and separating concerns.

Claims

1. A method, comprising:

categorically separating programmed logic from one or more programs into a plurality of object class files organized into a plurality of repositories, each repository named to identify a relationship, wherein each program is a complete and separate compiled program without compile-time dependencies on other programs;

during runtime of the one or more programs, accessing a repository location container identifying the name and location of at least one the repositories that is to be related to one or more other of the repositories during instantiation;

during said runtime, instantiating object class files in each repository identified in the repository location container into a plurality of executable instances in memory, wherein the created executable instances are separated into at least one repository of source instances, one or more repository of target instances;

examining during said runtime each of the source instances to collect information about one or more properties therein that is capable of being used as a source property, each source property having a unique source identifier associated therewith;

examining during said runtime each of the target instances to collect information about one or more properties therein that is capable of being used as a target property;

using the collected information to identify matches between the source properties and target properties; and

for each match, dynamically assigning to the target property during said runtime the unique source identifier of the corresponding source property to enable a static pathway for information traversals between the related source and target instances.

2. The method of claim 1, further comprising:

identifying during runtime one or more of the source instances intended for modification;

locating in each of the identified source instances a union initiation point from where an execution pointer jumps from that source instance to the one or more corresponding target instances that have been matched to the source instance;

dynamically creating in memory during runtime a union transmitter in each identified source instance, the union transmitter comprising a unique identifier that identifies the corresponding source instance and timing for the corresponding union initiation point; and

dynamically creating in memory during runtime in each corresponding inclusion instance a corresponding union receptor that matches to a corresponding union transmitter, the union receptor comprising a unique identifier that constrains instance execution to a corresponding union transmitter in a corresponding baseline instance.

3. The method of claim 2, wherein each union receptor is constrained during runtime to the matching union transmitter.

4. The method of claim 1, further comprising sequentially executing and monitoring blocks of programmed logic for specific messages in one of the programs having execution paths that cross at least one other program.

5. The method of claim 1, wherein the object class files from each repository identified in the repository location container are instantiated dynamically.

6. The method of claim 1, wherein the source instances and the target instances are sorted during runtime to create a specific execution sequence based on metadata found in the instances.

7. The method of claim 6, wherein the specific execution sequence exists independently of other programmed decision logic and is created, during runtime, from at least one of:

data within instances;

sequence of repository instantiation; and

name sequence of class object files within a repository.

8. The method of claim 1, wherein the source and target instances are examined during runtime to identify attributes named beans, wherein program object-identifiers associated with beans are copied into the identified attributes.

9. The method of claim 1, wherein the categorical separating of program logic includes separating program logic that initiates and monitors an execution cycle.

10. The method of claim 1, wherein the categorical separating of program logic includes separating program logic that represents a decision.

11. The method of claim 1, wherein the categorical separating of program logic includes separating program logic that represents a task.

12. The method of claim 1, wherein the categorical separating of program logic includes separating properties in program logic that is common to a plurality of programs.

13. The method of claim 1, wherein the repository location container is physically separate from compiled object class files.

14. The method of claim 1, wherein the instances are further separated into at least one repository of bean instances.

15. A system, comprising:

a computer having;

logic that categorically separates programmed logic from one or more programs into a plurality of object class files organized into a plurality of repositories, each repository named to identify a relationship, wherein each program is a complete and separate compiled program without compile-time dependencies on other programs;

logic that, during runtime of the one or more programs, accesses a repository location container identifying the name and location of at least one the repositories that is to be related to one or more other of the repositories during instantiation;

logic that, during said runtime, instantiates object class files in each repository identified in the repository location container into a plurality of executable instances in memory, wherein the created executable instances are separated into at least one repository of source instances, one or more repository of target instances;

logic that examines during said runtime each of the source instances to collect information about one or more properties therein that is capable of being used as a source property, each source property having a unique source identifier associated therewith;

logic that examines during said runtime each of the target instances to collect information about one or more properties therein that is capable of being used as a target property;

logic that uses the collected information to identify matches between the source properties and target properties; and

logic that, for each match, dynamically assigns to the target property during said runtime the unique source identifier of the corresponding source property to enable a static pathway for information traversals between the related source and target instances.

16. A system, comprising:

a circuit element that categorically separates programmed logic from one or more programs into a plurality of object class files organized into a plurality of repositories, each repository named to identify a relationship, wherein each program is a complete and separate compiled program without compile-time dependencies on other programs;

a circuit element that, during runtime of the one or more programs, accesses a repository location container identifying the name and location of at least one the repositories that is to be related to one or more other of the repositories during instantiation;

a circuit element that, during said runtime, instantiates object class files in each repository identified in the repository location container into a plurality of executable instances in memory, wherein the created executable instances are separated into at least one repository of source instances, one or more repository of target instances;

a circuit element that examines during said runtime each of the source instances to collect information about one or more properties therein that is capable of being used as a source property, each source property having a unique source identifier associated therewith;

a circuit element that examines during said runtime each of the target instances to collect information about one or more properties therein that is capable of being used as a target property;

a circuit element that uses the collected information to identify matches between the source properties and target properties; and

a circuit element that, for each match, dynamically assigns to the target property during said runtime the unique source identifier of the corresponding source property to enable a static pathway for information traversals between the related source and target instances.