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

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

What is claimed is:

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.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to software design of software architectures and, in particular, to the design of a software component architecture for the development of extensible tier software component applications, including compiled, interpreted, and on-the-fly applications.

2. Description of the Related Art

A variety of techniques are used by a programmer or code developer to design or generate software program code. In one approach, software applications are designed as "monolithic" structures in which the various functions, such as data storage and application logic, are completely entwined. For example, given a set of system specifications and functions which are to be implemented by a given application or program, the code developer designs a monolithic, independently executable program which implements the desired functions. The programmer may use, for example, a high-level programming language such as C++ and a code development tool to generate the high-level language, which is then compiled by a compiler to provide an executable version of the program.

One problem with this approach is that the applications are difficult to maintain, and separate functional portions of the program are difficult to reuse because all portions of the program are entwined and application-specific.

Accordingly, in the software field various software architectures have been developed in which application functionality is broken down into smaller units, such as objects or components. These units may be assembled to provide the overall functionality for a desired application. For example, a group of components may be assembled and compiled to provide a stand-alone, executable program. Alternatively, the components may be invoked and used in real-time, when the component's functionality is needed.

Because of the resource expenditure necessary to develop these units, it is desirable to be able to reuse these units, so that their functionality may be employed in subsequent applications without having to "re-invent the wheel" each time this functionality is needed. In current software architectures, such as two-tier and three-tier architectures, some portions, such as data repositories and user interfaces, are relatively easy to reuse. However, other types of components, such as those implementing application logic, are still clumped in large blocks, making reuse of these components or their various functions difficult. There is a need, therefore, for improved software component architectures and related software component development techniques that avoid the drawbacks of the prior art.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features, aspects, and advantages of the present invention will become more fully apparent from the following description, appended claims, and accompanying drawings in which:

FIG. 1 is a diagrammatic representation of the present invention's "N-tier architecture" paradigm;

FIG. 2 is a pictographic representation of a software factory;

FIG. 3 is a diagrammatic representation of a framework;

FIG. 4 is a flowchart diagram of rules;

FIG. 5 is a flowchart representation of the present invention's life cycle rules; and

FIG. 6 is a flowchart generally describing the present invention's method for designing a software architecture for use in generating software components.

DETAILED DESCRIPTION

Referring generally to FIG. 1, the present invention comprises a methodology that applies an engineering and manufacturing oriented approach to software production based on a well-defined architecture. As used herein, "manufacturing" implies a method analogous to a software factory. Using the present invention methodology, software application development can proceed as if it was a software manufacturing process with an assembly line capable of assembling all types of intellectual property quickly and at the lowest cost

The present invention uses an "N-tier architecture" paradigm. In an N-tier architecture, all functionality is broken down at the system level into logical chunks or tiers 30 that perform a well-defined business function. In the present invention's N-tier architecture there is no limit to the number of tiers 30.

The present invention's N-tier software design architecture is employed to develop software components 20 (shown in FIG. 1 as 20a, 20b, and 20c). As those of ordinary skill in the programming arts will appreciate, "N-tier" in the prior art may be thought of as implying a hierarchy such as with protocol stacks. However, as used herein, "N-tier" describes an architecture that is characterized by a plurality of "N" tiers 30, each of which has a specified type and a specified interface. Although a hierarchy can be defined for the tiers, no hierarchy is implicit in the N-tier architecture of the present invention.

Each software component 20 to be developed is associated with at least one tier 30, depending upon the nature of the functions to be performed by that software component 20 and tier 30. The present invention specifies a method and a system for creating architectures to implement an N-tier system wherein a software component designer can design or select each software component 20 to perform specified functionality and ensure that each software component 20 has the interfaces specified by the architecture for that tier 30.

Using the methodology of the present invention, there is no limit to the number of tiers 30 or software components 20 that can be implemented or defined. Rules for the architecture are specified whereby tiers 30 are not necessarily part of a hierarchy as in two- or three-tier systems, but are logically interconnected using standardized interfaces so that each tier 30 can interact with one or more other tiers 30 as needed, i.e., a software component 20 within a given tier 30 can interact with software components 20 of one or more other tiers 30 as necessary.

The following terms are understood to have the following meanings to those of ordinary skill in the programming arts for the present invention:

    TERM        DEFINITION
    Architecture A set of design principles and rules used to create a design.
    COM         Component Object Modeling.
    Component   An object that encapsulates, or hides, the details of how its
                functionality is implemented and has a well-defined
                interface reusable at a binary level.
    CORBA       Common Object Request Broker Architecture
    DCOM        Distributed Component Object Model
    DLL         Dynamic Link Library
    eventhandler message handling object
    Framework   An architected context for business objects that modify the
                business objects' attributes or add new behavior.
    GUID        Globally unique identifier, e.g. a number having a
                predetermined number of bits that uniquely identifies a
                software component
    JAVA        a programming language
    Model       A heterogeneous collection of components whose relation-
                ships are enforced via a predetermined set of rules; a
                collection or instantiation of software components where
                the collection or instantiation may be organized into a
                hierarchy
    Object      A programming structure encapsulating both data and
                functionality that are defined and allocated as a single unit
                and for which the only public access is through the
                programming structure's interfaces. A COM object must
                support, at a minimum, the IUnknown interface, which
                maintains the object's existence while it is being used and
                provides access to the object's other interfaces.
    Package     A logical grouping of interfaces within a framework that
                provide a specific behavior such as messaging or
                connecting.
    Sink        Connection sink for messaging.
    Source      Connection source for messaging
    Tier        A logical grouping of components that perform a
                well-defined, predetermined function.

• Inventors
  Green, David W.; Banks, Kevin L.; Kiowski, Jr., John W.;
• Assignee
  Baker Hughes Incorporated (Houston, TX)
• Published
  Feb-8-2005
• Current US Classes:
  717/102
  717/108
  717/117
• Application #
  746155
• International Classes
  G06F 009//44
• Field of Search
  717/100-120 717/124 707/201-228
• Examiner
  Dam; Tuan
• Agent
  Cantor Colburn LLP
• US Patent References:
  4828028
  4870564
  4916617
  5274572
  5303582
  5457797
  5466157
  5504672
  5815717
  5847975
  5848246
  5857197
  5881230
  5889520
  5889942
  5978582
  6006230
  6134594
  6182756
  6202200
  6263498
  6266666
  6446113