Method of and system for designing an N-tier software architecture for use in generating software components

• US 6,854,107 B2
• Filed: 12/22/2000
• Issued: 02/08/2005
• Est. Priority Date: 12/29/1999
• Status: Expired due to Fees

• Current Assignee: Baker Hughes Incorporated (Baker Hughes Company)
• Original Assignee: Baker Hughes Incorporated (Baker Hughes Company)
• Inventors: Green, David W., Banks, Kevin L., Kiowski, John W. Jr.
• Primary Examiner(s): Dam, Tuan
• Assistant Examiner(s): KENDALL, CHUCK O
• Application Number:
  US09/746,155
• Publication Number:
  US 20020095650A1
• Time in Patent Office: 1,509 Days
• Field of Search: 717100-120, 717/124, 707201-228
• US Class Current: 717/117
• CPC Class Codes: G06F 8/20 Software design

Abstract

A system and method for designing a software architecture for utilizing software components in building extensible N-tier software applications is described, the method comprising specifying a set of software component rules for creating software components; specifying a set of tier rules for creating tiers; and specifying a set of assembly rules further comprising association rules by which each tier may be associated with at least one software component and linkage rules by which each tier may be linked to at least one other tier. The tier rules may further comprise a set of association rules by which each tier created with the set of tier rules may be associated with at least one software component created using the software component rules; a set of tier framework rules to provide an architected context for software components within a tier; and a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier.

Claims

1. A method for designing a software architecture for utilizing software components in building N-tier software applications, the method comprising:

a) specifying a set of software component rules for developing software components;

b) specifying a set of tier rules for developing a plurality of tiers wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object, the tier rules further comprising;

i) a set of association rules by which at least one software component developed using the software component rules is associated with or disassociated from at least one tier developed with the set of tier rules;

ii) a set of tier framework rules to provide an architected context for software components associated with a tier; and

iii) a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier; and

c) specifying a set of assembly rules, by which each tier is associated and linked to at least one other tier.

2. The method of claim 1 wherein specifying the set of software component rules for developing software components further comprises:

specifying rules for specifying interfaces for each software component; and

specifying rules for specifying behavior exhibited by each software component.

3. The method of claim 2 wherein specifying rules for specifying behavior further comprises:

specifying rules for encapsulating each software component; and

specifying rules for developing an interface reusable at a binary level for each software component;

whereby each software component is made available for use by any other software component that uses interface of the software component.

4. The method of claim 1 further comprising specifying library rules for selectively placing software components into and retrieving software components from an inventory of software components.

5. The method of claim 1 wherein the software component rules comprise rules for supporting off-the-shelf components within software components or tiers, including rules to allow addition of off-the-shelf software components into the inventory.

6. The method of claim 1 further comprising specifying at least one software component modification rule for adding, modifying, or deleting software components.

7. The method of claim 1 wherein the software component rules further comprise rules for designating software component function points.

8. The method of claim 7 wherein the rules for designating software component function points further comprise rules to allow implementing software component interfaces required by a particular tier to which the software component belongs.

9. The method of claim 1 wherein specifying a set of tier rules for developing an extensible set of tiers further comprises:

specifying rules for modifying software component attributes of software components associated with the tier;

specifying rules for determining dependencies between a framework and at least one other framework;

specifying rules for grouping properties and interfaces in the framework;

specifying rules for determining interfaces to be used in the framework.

10. The method of claim 1 wherein the framework rules further comprise rules on specifying at least one package for a framework, the package further comprising a set of interfaces to provide a specific behavior.

11. The method of claim 1 further comprising:

specifying a basic design structure comprising base components for software components in the tier; and

specifying a set of standard interfaces for the software components categorized as belonging to the tier.

12. The method of claim 1 wherein specifying the set of assembly rules further comprises:

specifying rules to allow assembling and compiling at least one tier to provide a stand-alone, executable program; and

specifying rules on allowing combining software components and invoking an assembled application at run-time to form new unique applications on-the-fly.

13. The method of claim 1 wherein the software component rules specify rules allowing each software component to execute asynchronously within its own thread and time frame and to inform dependent components of its status or provide dependent components with information when predetermined events occur.

14. The method of claim 1 further comprising specifying rules to allow defining one or more techniques to allow a software component to traverse a model, the model comprising one or more software components.

15. The method of claim 14 wherein the traversal of a model uses a predetermined interface.

16. The method of claim 1 further comprising specifying rules on implementing a template iterator class to facilitate accessing associations.

17. The method of claim 16 wherein the template iterator class is based on an association of software components and is used to iterate through all software components in the association or through a specific software component type.

18. A method for generating software components for use in an N tier software application, the software components having a predetermined structure, the method comprising:

providing a software component architecture comprising a plurality of tiers, wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object, each tier further comprising a predetermined set of interfaces for that tier, the interfaces defining a set of functionality capable within that tier;

specifying a set of association rules by which at least one software component developed using software component rules is associated with or disassociated from at least one tier developed with a set of tier rules;

specifying a set of tier framework rules to provide an architected context for software, components associated with a tier;

specifying package rules to provide for logical grouping of interfaces within a framework defined, by the tier framework rules to provide specific behaviors for the tiers;

specifying a set of assembly rules by which each tier is associated and linked to at least one other tier; and

wherein at least one of the software components in a selected one of the plurality of tiers provides a predetermined set of interfaces.

19. The method of claim 18 wherein the software components of a tier are reusable by a system configured to utilize the set of interfaces associated with the tier.

20. The method of claim 18 wherein the tier framework rules further comprise:

specifying rules for determining dependencies between a framework and at least one other framework;

specifying how properties and interfaces are grouped in the framework; and

specifying the interfaces to be used in the framework.

21. The method of claim 20 further comprising specifying rules on defining packages within the framework, each package comprising a group of interfaces that specify how a specific behavior is to be implemented in the framework.

22. A method of system design for an N-tier architecture, the architecture comprising software components and tiers, the method comprising:

determining a set of application requirements;

determining a list of software components to satisfy the application requirements, wherein each software components comprises a software object;

logically grouping the software components into extensible tiers, the tiers having a set of tier rules, the tier rules comprising a set of association rules by which at least one software components developed using software component rules is associated with or disassociated from at least one tier developed with the set of tier rules, the tier rules further comprising a set of tier framework rules to provide an architected context for software components associated with a tier, the tier rules further comprising a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier;

specifying a set of rules by which each tier is associated and linked to at least one other tier.

23. The method of claim 22 further comprising:

testing each added software component;

testing each restructured software component;

assessing each added software component for suitability to become part of the software inventory;

assessing each restructured software component for suitability to become part of the software inventory; and

adding at least a portion of the added or restructured components to the inventory.

24. The method of claim 22 wherein the added or restructured software components are either tailored into the current architecture or the architecture is expanded by adding one or more tiers to accommodate the added or restructured software component.

25. The method of claim 22 where the software components that are only to be utilized in a current application are not added to the inventory.

26. The method of claim 22 wherein adding additional software components if no existing software component in the inventory satisfies a requirement or is modifiable to satisfy the requirement, further comprises:

procuring an off-the-shelf software component from a third party; and

providing the off-the-shelf software component with a predetermined interface to interface between the off-the-shelf software component and at least one tier.

27. A system for designing a software architecture for use in, generating software components for building software applications, the system comprising:

at least one processing unit;

at least one memory store operatively connected to the processing unit;

N-tier design software executable within the at least one processing unit, wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object;

software architecture specifications resident in the memory store for use by the N tier design software, the software architecture specifications comprising specifications for a set of software component rules for developing software components, specifications of a set of tier rules for developing tiers, and specifications of a set of assembly rules the tier rules comprising a set of association rules by which at least one software component developed using software component rules is associated with or disassociated from at least one tier developed with a set of tier rules, the tier rules further comprising a set of tier framework rules to provide an architected context for software components associated with a tier, the tier rules further comprising a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier, the set of assembly rules associating and linking each tier with at least one other tier;

an input device, operatively in communication with the processing unit, for permitting input of the software architecture specifications;

an output device, operatively in communication with the processing unit; and

a communications pathway operatively connected to the processing unit.

28. The system of claim 27 wherein the communications pathway is a network.

29. The system of claim 28 wherein the network utilizes at least one of asynchronous communication and synchronous communication between the software components.

30. A system for designing a software architecture for use in generating software for building software applications, the system comprising:

a) means for specifying a set of software component rules for developing software components;

b) means for specifying a set of tier rules for developing a plurality of tiers wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object, the tier rules further comprising;

i) a set of association rules by which each tier developed with the set of tier rules is associated with at least one software component developed using the software component rules;

ii) a set of tier framework rules to provide an architected context for software components within a tier; and

iii) a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier; and

c) means for specifying a set of assembly rules further comprising association rules by which each tier is associated with at least one software component and linkage rules by which each tier is linked to at least one other tier.

31. A method for defining and implementing an N-tier software architecture for a system comprising at least one processing unit, at least one memory store operatively connected to the processing unit, N-tier designing software executable within the at least one processing unit, an input device operatively in communication with the processing unit for permitting input of the software architecture specifications, an output device operatively in communication with the processing unit, and a communications pathway operatively connected to the processing unit, the method comprising:

a) loading the N-tier designing software into the memory store;

b) executing the N-tier designing software;

c) inputting a set of software component rules for developing software components into the memory store;

d) inputting a set of tier rules for developing a plurality of tiers into the memory store, the tier rules further comprising;

i) a set of association rules by which each tier developed with the set of tier rules is associated with at least one software component developed using the software component rules;

ii) a set of tier framework rules to provide an architected context for software components within a tier; and

iii) a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier,

e) inputting a set of assembly rules into the memory store, the assembly rules further comprising association rules by which each tier is associated with at least one software component and linkage rules by which each tier is linked to at least one other tier; and

f) processing the software component rules, tier rules, and assembly rules using the N-tier designing software to develop an N-tier software architecture, wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object.

32. An N-tier software architecture stored in a storage media, the storage media comprising;

a first plurality of binary values for developing software components using software component rules;

a second plurality of binary values for developing a plurality of tiers using tier rules wherein each tier comprises a plurality of software components and performs a predetermined function, each software component comprising a software object, the tier rules comprising a set of association rules by which at least one software component developed using software component rules is associated with or disassociated from at least one tier developed with the set of tier rules, the tier rules further comprising a set of tier framework rules to provide an architected context for software components associated with a tier, the tier rules further comprising a set of package rules to provide for logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors for the tier; and

a third plurality of binary values for assembling software applications from tiers and software component, the third plurality of binary value associating and linking each tier with at least one other tier.

33. An article of manufacture, comprising;

a computer storage medium having a computer program encoded therein for designing a software architect for utilizing software components in building multiple tier software applications, the computer storage medium including;

code for specifying a set of software component rules for developing software components wherein each software component comprises a software object;

code for specifying a set of tier rules for developing a plurality of tiers wherein each tier comprises a plurality of software components and performs a predetermined function, the tier rules comprising a set of association rules by which at least one software component developed using software component rule is associated with or disassociated from at least one tier developed with the set of tier rules, the tier rules further comprising a set of tier framework rues to provide an architected context for software components associated with a tier, the tier rules further comprising a set of package rules to provide or logical grouping of interfaces within a framework defined by the tier framework rules to provide a set of specific behaviors or the tier; and

code for specifying a set of assembly rules by which each tier is associated and linked to at least one other tier.