Method and apparatus for the development of dynamically configurable software systems

• US 6,269,473 B1
• Filed: 03/23/1998
• Issued: 07/31/2001
• Est. Priority Date: 03/23/1998
• Status: Expired due to Term

• Current Assignee: Oracle Systems Corporation (Oracle Corporation)
• Original Assignee: Evolve Softworks LLC
• Inventors: Anderson, Brian, Saville, Richard John, Noyes, Thomas James, Freed, Erik
• Primary Examiner(s): Chaki, Kakali
• Assistant Examiner(s): DAM, TUAN QUANG
• Application Number:
  US09/046,624
• Time in Patent Office: 1,226 Days
• Field of Search: 395/701, 395/500.43, 395/500.38, 706/919-920, 706/922, 706/45-47, 706/55, 706/50, 706/49, 707/104, 707/103, 709/300, 709/317, 709/332, 717/1, 717/2, 717/10, 703/22
• US Class Current: 717/104
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 9/44505 Configuring for program initiating, e.g. using registry, configuration files
• CPC Class Codes: Y10S 706/919 Designing, planning, programming, CAD, CASE

Abstract

A software modeling environment is presented that supports the development and execution of software that can be dynamically configured. This is achieved by introducing a design-time object modeling construct called a dynamically configurable type (DCT) that supports the subdivision of an object into a plurality of subsets of semantics and allows dynamic merging of these semantic subsets together in different combinations in order to allow the resultant object to exhibit different semantics over time to serve different purposes. Specific process modeling constructs are included which take advantage of this semantic merging capability. Also included are other supporting design-time and run-time constructs and services. One embodiment of the present invention allows this software modeling environment to be integrated into a standard software development environment, enhancing the modeling capabilities already present.

Claims

1. A method of developing dynamically configurable software systems (DCSS) comprising:

(a) defining and creating one or more dynamically configurable types (DCTs) each with an associated plurality of defined collections of semantics, wherein the DCTs are collectively representative of a software solution to a problem, wherein the DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the DCTs; and

(b) coupling the DCTs to predefined software services that at run-time will support DCOs, including the ability to combine the defined collections of semantics together in permutations at run-time in order to allow the DCOs to have different semantics over time to serve different purposes so that a software solution based on the DCOs allows dynamic configurability.

2. The method of claim 1 further comprising the step of:

(c) generating computer executable code from a combination of the plurality of DCTs, and the predefined software services.

3. The method of claim 2 further comprising the step of:

(d) executing the resultant computer executable code so as to provide to a user the benefits of the software solution to a problem.

4. The method of claim 1 further comprising the step of:

(e) Providing software to automate step (a).

5. The method of claim 1 wherein step (a) further comprises the step of:

(f) defining and creating certain DCTs to be dynamically configurable subprocesses (DCSs), wherein a run-time instance of each of the identified DCSs is a root of a graph including a set of DCOs coupled together to perform a part or the totality of a processing goal, and to provide a service context for run-time operations involving the set of DCOs.

6. The method of claim 5 wherein step (a) further comprises the step of:

(g) defining and creating certain DCTs to be dynamically configurable processes (DCPs), wherein a run-time instance of a DCP includes one or more instances of a DCS and which controls and supports operations performed on the instances of a DCS in order to achieve a larger processing goal subdividing it into a set of smaller processing goals, each smaller processing goal achieved by one or more of the DCS instances.

7. The method of claim 1 wherein the combining of step (b) includes:

(h) merging different collections of semantics in the plurality of collections of semantics in the plurality of DCTs to implement a software solution to the problem.

8. The method of claim 1 wherein the combining of step (b) includes:

(i) merging collections of semantics in a specific DCT with collections of semantics in more general DCTs wherein the DCTs are organized into a hiearchy.

9. The method of claim 8 wherein the combining of step (b) includes:

(j) selecting particular collections of semantics to be merged at each level of the hiearchy based on a shared identity in a common set of identities defined by a union of identities of all pluralities of collections of semantics from each of a set of those DCTs that are on a inclusive path from the specific DCT to the most general DCT in the hiearchy.

10. The method of claim 1 wherein step (a) further comprises the step of:

(k) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time.

11. The method of claim 10 wherein step (k) further comprises the step of:

(l) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time where in each configuration contains a set of identities for the collections of semantics to be combined.

12. The method of claim 10 wherein step (k) further comprises the step of:

(m) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time wherein each configuration contains a function that calculates a set of collections of semantics to be combined at run-time.

13. The method of claim 1 wherein step (a) further comprises the steps of:

(n) defining and creating, for each DCT, a plurality of property sets wherein each property set is representative of a collection of semantics; and

(o) defining and creating for each of the property sets in the plurality of property sets a plurality of properties.

14. The method of claim 13 further comprising the step of:

(p) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time.

15. The method of claim 13 wherein step (n) includes the steps of:

(q) defining and creating one of the plurality of property sets to be a base property set.

16. The method of claim 13 further comprising the step of:

(r) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time where in each configuration contains a set of identities for the property sets to be combined.

17. The method of claim 13 further comprising the step of:

(s) defining and creating, for each DCT, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time wherein each configuration contains a function that calculates a set of property sets to be combined at run-time.

18. The method of claim 13 wherein step (o) further comprises the step of:

(t) defining and creating properties to represent relationships to instances of other DCTs.

19. The method of claim 13 wherein step (o) further comprises the step of:

(u) defining and creating properties to represent methods on the DCT; and

(v) defining method implementations for each of the represented methods.

20. The method of claim 13 wherein step (o) further comprises the step of:

(w) defining and creating properties to represent rules on the DCT, wherein the rules are a specification of how to respond to events received by the DCT.

21. The method of claim 13 wherein the combining of step (b) includes:

(x) merging different property sets in the plurality of property-sets in the plurality of DCTs to implement a software solution to the problem.

22. The method of claim 13 wherein the combining of step (b) includes:

(y) merging different properties in the property sets in the plurality of property-sets in the plurality of DCTs to implement a software solution to the problem.

23. The method of claim 13 wherein step (b) includes:

(z) merging property sets in a specific DCT with property sets in more general DCTs wherein the DCTs are organized into a hiearchy.

24. The method of claim 22 wherein the combining of step (b) includes:

(aa) selecting particular property sets to be merged at each level of the hiearchy based on a shared identity in a common set of identities defined by the union of identities of all pluralities of property sets from each of a set of those DCTs that are on a inclusive path from the specific DCT to the most general DCT in the hiearchy.

25. The method of claim 13 wherein step (o) includes the step of:

(ab) defining and creating, for each property in each property set, a precedence which determines which property will be chosen during the combining of step (b), from among properties of the same identity in other property sets.

26. The method of claim 25 wherein the combining of step (b) includes:

(ac) merging different properties in the property sets in the plurality of property-sets in the plurality of DCTs to implement a software solution to the problem based on precedence, wherein the precedence identifies the property that is the result of the merge.

27. The method of claim 13 wherein step (o) includes the steps of:

(ad) defining and creating for each property, in each property set, a feature set containing a plurality of features;

wherein each feature set defines combinable characteristics of the associated property;

(ae) defining and creating for each feature in the feature set, a feature kind which defines a kind of combinable characteristic that the feature represents in the associated property; and

(af) defining and creating how the feature of the associated property will be combined in step (b) with features of the same feature kind in other properties having the same identity in other property sets.

28. The method of claim 27 wherein step (ad) further comprises the step of:

(ag) defining and creating configuration feature kinds that represent transactional characteristics of a property.

29. The method of claim 27 wherein step (ad) further comprises the step of:

(ah) defining and creating configuration feature kinds that represent event handling characteristics of a property.

30. The method of claim 27 wherein step (ad) further comprises the step of:

(ai) defining and creating configuration feature kinds that represent user interface visualization and event handling characteristics of a property.

31. The method of claim 27 wherein the combining of step (b) includes:

(aj) merging different features of the properties in the property sets in the plurality of property-sets in the plurality of DCTs to implement a software solution to the problem.

32. The method of claim 27 wherein step (a) includes the step of:

(ak) defining and creating, for each feature in each feature set, a precedence which determines which feature will be chosen during the combining of step (b), from among features of the same kind in properties of the same identity in other property sets.

33. The method of claim 32 wherein the combining of step (b) includes:

(al) merging different features of the properties in the property sets in the plurality of property-sets in the plurality of DCTs to implement a software solution to the problem based on precedence, wherein the precedence identifies the feature that is the result of the merge.

34. The method of claim 33 wherein the combining of step (b) includes:

(am) sharing an identity for the properties being merged among a common set of identities based on a shared identity in a common set of identities defined by a union of identities of all the pluralities of property sets from each of a set of those DCTs that are on an inclusive path from a specific DCT to a most general DCT wherein the DCTs are disposed in a hiearchy.

35. The method of claim 1 wherein step (a) further includes:

(an) defining and creating of data structures and algorithms that allow storage, modification, and retrieval at run-time of a plurality of policy decisions that can be used to direct dynamic configuration of DCOs, wherein the DCSS changes at run-time in reaction to modifications of the plurality of policy decisions.

36. The method of claim 35 wherein step (a) further includes:

(ao) defining and creating of data structures and algorithms that support the presentation at run-time of a plurality of questions to a DCSS user, wherein a plurality of answers that the user provides in response to the plurality of questions are processed and stored as policy decisions.

37. The method of claim 1 wherein step (b) further includes:

(ap) coupling the DCTs to services that support the management and control of multiple DCOs connected together within a run-time context.

38. The method of claim 1 wherein step (a) further includes the step of defining and creating user interface definitions for each of the plurality of DCTs;

and wherein step (b) further includes the step of providing services that support generation of a user interface from the user interface definitions each time a DCO undergoes configuration at run-time.

39. The method of claim 1 wherein step (a) further includes the step of defining and creating event response definitions for each of the plurality of DCTs;

and wherein step (b) further includes the step of providing services that support the scheduling and execution of changing event responses from the event response definitions each time a DCO undergoes configuration at run-time.

40. The method of claim 1 wherein step (a) further includes the step of defining and creating transaction definitions for each of the plurality of DCTs;

and wherein step (b) further includes the step of providing services that support transactionality at run-time.

41. The method of claim 1 wherein step (a) further includes the step of defining and creating persistence definitions for each of the plurality of DCTs;

and wherein step (b) further includes the step of providing services that support persistence at run-time.

42. A method of developing dynamically configurable software systems (DCSS) comprising:

(a) Defining one or more dynamically configurable types (DCTs) each with an associated plurality of collections of semantics, wherein the one or more DCTs are collectively representative of a software solution to a problem, wherein the one or more DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the one or more DCTs; and

(b) Using the one or more DCTs to create a software solution to a problem.

43. A method of developing dynamically configurable software systems (DCSS) comprising:

(a) providing an environment for defining and executing one or more dynamically configurable types (DCTs) each with an associated plurality of defined collections of semantics, wherein the DCTs are collectively representative of a software solution to a problem, wherein the DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the DCTs; and

(b) coupling defined DCTs to predefined software services that at run-time will support DCOs, including the ability to combine the defined collections of semantics together in permutations at run-time in order to allow the DCOs to have different semantics over time to serve different purposes so that a software solution based on the DCOs allows dynamic configurability.

44. The method of claim 43 further comprising the step of:

(c) creating computer executable code from a combination of the plurality of DCTs, and the predefined software services.

45. The method of claim 44 further comprising the step of:

(d) executing the resultant computer executable code so as to provide to a user the software solution to a problem.

46. The method of claim 44 further comprising the step of:

(f) executing the resultant computer executable code so as to provide to a developer of a DCSS the benefits of the environment for defining and executing the software solution to a problem.

47. The method of claim 43 further comprising the step of:

(e) creating computer executable code that automates the definition of DCTs.

48. An apparatus for executing dynamically configurable software structures comprising:

(a) a plurality of dynamically configurable objects (DCOs) that each represent a run-time instantiation of a dynamically configurable type (DCT);

(b) a plurality of dynamically configurable relationships in each DCO each of which defines a coupling between one DCO and another;

(c) one or more DCO networks which include an arrangement of some of the plurality of DCOs based on the associated dynamically configurable relationships, each DCO network further having a root position, and each DCO network further operable to manage the generation, propagation, and reception of events within each DCO network;

(d) one or more dynamically configurable subprocesses (DCSs) which are disposed at the root position of the DCO network and control all operations performed within the DCO network;

(e) one or more dynamically configurable processes (DCPs) which contain a plurality of DCSs and support and manage all operations performed on each of, and the totality of the plurality of DCSs; and

(f) one or more services that provide support for the DCOs.

49. The apparatus of claim 48 wherein the services include:

(g) A persistence service which provides for storing, querying, retrieval and updating of the plurality of DCOs to and from a persistent data storage system.

50. The apparatus of claim 48 wherein the services include:

(h) A transaction service which provides transactional capabilities for the plurality of DCOs.

51. The apparatus of claim 48 wherein the services include:

(i) A rules service which provides for mapping of events to method invocations on DCOs.

52. The apparatus of claim 48 wherein the services include:

(j) a configuration service which configures and re-configures the DCOs.

53. The apparatus of claim 48 wherein the services include:

(k) a factory service which provides for the creation of DCOs and the retrieval of the DCO based on their identity from the persistence service.

54. A method of developing dynamically configurable software systems comprising:

(a) Defining a plurality of dynamically configurable types each with an associated plurality of collections of semantics, wherein the plurality of dynamically configurable types are collectively representative of a software solution to a problem;

(b) Providing configuration services that at run-time will configure the dynamically configurable types by combining one or more of the collections of semantics in each of the plurality of dynamically configured types;

(c) Creating computer executable code from a combination of the plurality of dynamically configurable types and the configuration services; and

(d) Executing the computer executable code wherein dynamically configurable types are configured through application of the configuration services.

55. The method of claim 54 wherein step (a) further includes:

(e) defining and creating certain dynamically configurable types to be dynamically configurable subprocess types;

wherein a run-time instance of each of the identified DCTs is the root of a graph consisting of a set of instances of DCTs connected at run-time to perform a processing goal, and to provide a run-time service context for run-time operations involving the set of instances of DCTs.

56. The method of claim 55 wherein step (a) includes:

(f) defining and creating certain dynamically configurable types to be dynamically configurable process types;

wherein the dynamically configurable process type includes a plurality of the dynamically configured subprocess objects and which controls all operations performed on the plurality of dynamically configured subprocess type instances.

57. The method of claim 54 wherein the combining of step (b) includes:

(g) merging different collections of semantics in the plurality of collections of semantics in the plurality of dynamically configurable types to implement a software solution to the problem.

58. The method of claim 54 wherein the combining step of (b) includes:

(h) combining collections of semantics in a specific DCT with collections of semantics in more general DCTs wherein the DCTs are organized into a hierarchy.

59. The method of claim 58 wherein the combining of step (b) includes:

(i) selecting particular collections of semantics to be merged at each level of the hiearchy based on a shared identity in a common set of identities defined by a union of identities of all pluralities of collections of semantics from each of a set of those DCTs that are on a inclusive path from the specific DCT to the most general DCT in the hiearchy.

60. The method of claim 54 wherein step (a) includes the step of:

(k) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time.

61. The method of claim 60 wherein step (j) comprises the following steps:

(k) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time where in each configuration contains a set of identities for the collections of semantics to be combined.

62. The method of claim 60 wherein step (j) comprises the following steps:

(l) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of collections of semantics to be combined at run-time wherein each configuration contains a function that calculates a set of collections of semantics to be combined at run-time.

63. The method of claim 54 wherein step (a) comprises the steps of:

(m) defining and creating, for each dynamically configurable types, a plurality of property sets wherein each property set is representative of a collection of semantics; and

(n) defining and creating for each of the property sets in the plurality of property sets a plurality of properties.

64. The method of claim 63 wherein further including the step of:

(o) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time.

65. The method of claim 63 wherein step (m) includes the steps of:

(p) defining and creating a one of the plurality of property sets to be a base property set.

66. The method of claim 63 wherein step (j) comprises the following steps:

(q) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time where in each configuration contains a set of identities for the property sets to be combined.

67. The method of claim 63 wherein step (j) comprises the following steps:

(r) defining and creating, for each dynamically configurable type, a plurality of configurations, each of which can be used to identify a set of property sets to be combined at run-time wherein each configuration contains a function that calculates a set of property sets to be combined at run-time.

68. The method of claim 63 wherein step (n) includes:

(s) defining and creating properties to represent relationships to instances of other dynamically configurable types.

69. The method of claim 63 wherein step (n) includes:

(t) defining and creating properties to represent methods on the dynamically configurable type; and

(u) defining method implementations for each of the represented methods.

70. The method of claim 63 wherein step (n) includes:

(v) defining and creating properties to represent rules on the dynamically configurable type;

wherein the rules are a specification of how to respond to events received by the dynamically configurable type.

71. The method of claim 63 wherein the combining of step (b) includes:

(w) merging different property sets in the plurality of property-sets in the plurality of dynamically configurable types to implement a software solution to the problem.

72. The method of claim 63 wherein the combining of step (b) includes:

(x) merging different properties in the property sets in the plurality of property-sets in the plurality of dynamically configurable types to implement a software solution to the problem.

73. The method of claim 63 wherein step (b) includes:

(y) combining property sets in a specific DCT with property sets in more general DCTs wherein the DCTs are organized into a hiearchy.

74. The method of claim 73 wherein the combining of step (b) includes:

(z) selecting particular property sets to be merged at each level of the hiearchy based on a shared identity in a common set of identities defined by the union of identities of all pluralities of property sets from each of a set of those DCTs that are on a inclusive path from the specific DCT to the most general DCT in the hiearchy.

75. The method of claim 63 wherein step (n) includes the step of:

(aa) defining and creating, for each property in each property set, a precedence which determines which property will be chosen during the combining of step (b), from among properties of the same identity in other property sets.

76. The method of claim 75 wherein the combining of step (b) includes:

(ab) merging different properties in the property sets in the plurality of property-sets in the plurality of dynamically configurable types to implement a software solution to the problem based on precedence, wherein the precedence identifies the property that is the result of the merge.

77. The method of claim 63 wherein step (n) includes the steps of:

(ac) defining and creating for each property, in each property set, a feature set containing a plurality of features;

wherein each feature set defines combinable characteristics of the associated property;

(ad) defining and creating for each feature in the feature set, a feature kind which defines a kind of combinable characteristic that the feature represents in the associated property; and

(ae) defining and creating how the feature of the associated property will be combined in step (b) with features of the same feature kind in other properties having the same identity in other property sets.

78. The method of claim 77 wherein step (ad) includes:

(af) defining and creating configuration feature kinds that represent transactional characteristics of a property.

79. The method of claim 77 wherein step (ad) includes:

(ag) defining and creating configuration feature kinds that represent event handling characteristics of a property.

80. The method of claim 77 wherein step (ad) includes:

(ah) defining and creating configuration feature kinds that represent user interface visualization and event handling characteristics of a property.

81. The method of claim 77 wherein the combining of step (b) includes:

(ai) merging different features of the properties in the property sets in the plurality of property-sets in the plurality of dynamically configurable types to implement a software solution to the problem.

82. The method of claim 77 wherein step (ae) includes the step of:

(aj) defining and creating, for each feature in each feature set, a precedence which determines which feature will be chosen during the combining of step (b), from among features of the same kind in properties of the same identity in other property sets.

83. The method of claim 82 wherein the combining of step (b) includes:

(ak) merging different features of the properties in the property sets in the plurality of property-sets in the plurality of dynamically configurable types to implement a software solution to the problem based on precedence, wherein the precedence identifies the feature that is the result of the merge.

84. The method of claim 83 wherein the combining of step (b) includes:

(al) sharing an identity for the properties being merged among a common set of identities based on a shared identity in a common set of identities defined by a union of identities of all the pluralities of property sets from each of a set of those DCTs that are on an inclusive path from a specific DCT to a most general DCT wherein the DCTs are disposed in a hiearchy.

85. An apparatus for executing dynamically configurable software structures comprising:

(a) a plurality of dynamically configurable objects that each represent a run-time instantiation of a dynamic configurable type each having an identity;

(b) a plurality of dynamically configurable relationships in each dynamically configurable object, each of which defines a coupling between one dynamically configurable object and another;

(c) one or more dynamically configurable object networks which include an arrangement of some of the plurality of dynamically configurable objects based on the associated dynamically configurable relationships, each dynamically configurable object network further having a root position, and each dynamically configurable object network further operable to manage the generation, propagation, and reception of events within each dynamically configurable object network;

(d) one or more dynamically configurable action objects which are disposed at the root position of the dynamically configurable object network and operable to control operations performed within the dynamically configurable object network;

(e) a persistence service which provides for storing, querying, retrieval and updating of the dynamically configurable objects to and from a persistent data storage system;

(f) a transaction service which provides transactional capabilities for the plurality of dynamically configurable objects;

(g) a factory service which provides for the creation of the dynamically configurable objects and the retrieval of the dynamically configurable objects based on their identity from the persistence service;

(h) a client process;

(i) a session service which provides authentication and connection management for the client process to interact with the dynamically configurable software structures;

(j) a manifestation service which provides to the client process an abstracted representation of dynamically configurable action objects and forwards events generated by the client process to the represented dynamically configurable object network;

(k) a rules service which provides for mapping of events to method invocations on dynamically configurable objects; and

(l) a configuration service which configures and re-configures the dynamically configurable objects.

86. An apparatus for developing dynamically configurable software systems (DCSS) comprising:

(a) means for defining, one or more dynamically configurable types (DCTs) each with an associated plurality of collections of semantics, wherein the one or more DCTs are collectively representative of a software solution to a problem, wherein the one or more DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the one or more DCTs; and

(b) means for using the one or more DCTs to create a software solution to a problem.

87. An article of manufacture comprising a computer usable medium having a computer readable program code embodied in said medium for developing and executing dynamically configurable software, the computer readable program code in said article of manufacture comprising:

(a) computer readable instructions for enabling the computer to allow defining and creating of one or more dynamically configurable types (DCTs) each with an associated plurality of defined collections of semantics, wherein the DCTs are collectively representative of a software solution to a problem, wherein the DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the DCTs; and

(b) computer readable instructions for enabling the computer to allow coupling the DCTs to predefined software services that at run-time will support DCOs including the ability to combine the defined collections of semantics together in permutations at run-time in order to allow the DCOs to have different semantics over time to serve different purposes so that a software solution based on the DCOs allows dynamic configurability.

88. An apparatus for developing dynamically configurable software systems (DCSS) comprising:

(a) means for defining and creating, one or more dynamically configurable types (DCTs) each with an associated plurality of defined collections of semantics, wherein the DCTs are collectively representative of a software solution to a problem, wherein the DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the DCTs; and

(b) means for coupling the DCTs to predefined software services that at run-time will support DCOs including the ability to combine the defined collections of semantics together in permutations at run-time in order to allow the DCOs to have different semantics over time to serve different purposes so that a software solution based on the DCOs allows dynamic configurability.

89. A transmission medium comprising a computer accessible medium transmitting a computer readable program code embodied in said transmission for developing and executing dynamically configurable software, the computer readable program code in said transmission medium comprising:

(a) computer readable instructions for enabling the computer to allow defining and creating of one or more dynamically configurable types (DCTs) each with an associated plurality of defined collections of semantics, wherein the DCTs are collectively representative of a software solution to a problem, wherein the DCTs are used to model the run-time behavior of dynamically configurable objects (DCOs) which are instances of the DCTs; and

(b) computer readable instructions for enabling the computer to allow coupling the DCTs to predefined software services that at run-time will support DCOs including the ability to combine the defined collections of semantics together in permutations at run-time in order to allow the DCOs to have different semantics over time to serve different purposes so that a software solution based on the DCOs allows dynamic configurability.