Producer graph oriented programming and execution

• US 20080134138A1
• Filed: 12/01/2006
• Published: 06/05/2008
• Est. Priority Date: 12/01/2006
• Status: Active Grant

• Current Assignee: Murex S.A.S.
• Original Assignee: Murex S.A.S.
• Inventors: Edde, Elias, Chamieh, Fady
• Granted Patent: US 8,191,052 B2
• Time in Patent Office: Days
• US Class Current: 717/105
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/315 Object-oriented languages
• CPC Class Codes: G06F 8/41 Compilation
• CPC Class Codes: G06F 9/4488 Object-oriented
• CPC Class Codes: G06F 9/4494 data driven
• CPC Class Codes: G06F 9/45508 Runtime interpretation or emulation, e g. emulator loops, bytecode interpretation

Abstract

A method and apparatus for producer graph oriented programming and execution. According to one aspect of the invention, a runtime is provided that interprets producer dependency declarations for methods. The producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance. The runtime automatically generates and executes, responsive to receiving a designation of a producer of interest whose method has a producer dependency declaration, a producer graph. The producer graph initially includes the producer of interest and is generated, from the producer of interest to source producers, through instantiation of producers based on the producer dependency declarations of the methods of the producers already in the producer graph. The runtime sequences the execution of the producers in the producer graph as indicated by the producer graph.

Claims

1. An apparatus for executing object-oriented code, said apparatus comprising:

a runtime that interprets producer dependency declarations for methods in the object-oriented code, said producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, the runtime including,

an automated producer graph generation module to receive a designation of a producer of interest, to add the producer of interest as part of a producer graph, and to automatically generate a remainder of the producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the producer graph, and

a producer graph execution module to execute the producers in the producer graph in the order indicated by the producer graph, wherein execution of each producer results in the method of the producer being executed on the instance of the producer.

36. The apparatus of claim 1, wherein said automated producer graph generation module may not initially be able to complete generation of the producer graph until some producers of the producer graph are executed, and wherein said producer graph execution module may invoke the automated producer graph generation module with needed producer outputs during execution of the producer graph to complete unresolved remainders of the producer graph.

37. The apparatus of claim 1, wherein the set of producers that will be identified at run time by at least one of said producer dependency declarations includes at least one producer to be executed before the execution of the producer that includes the method of that producer dependency declaration.

38. The apparatus of claim 1, wherein said producer graph represents appropriate sequencing of execution as identified by the producer dependency declarations of the methods of the producers in the producer graph.

39. The apparatus of claim 1, wherein the set of producers that will be identified at run time by at least one of said producer dependency declarations for a given method includes at least one producer with an output that is a direct input to the given method.

40. The apparatus of claim 1, wherein the producer graph represents the direct input to output dependencies of the producers on each other from the producer of interest to those of the producers that are end nodes of the producer graph.

41. The apparatus of claim 1, wherein the runtime further comprises:

an override producer output module to receive current modifications to the output of one or more of the producers in a current version of the producer graph;

a producer graph structure, coupled to the automated producer graph generation module, to store the current version of the producer graph and the current output of each of the producers in the current producer graph; and

said producer graph execution module, coupled to the override producer output module and the producer graph structure, to make the current modifications, to track which producers in the current version of the producer graph need to be executed because they are indirectly affected by any of the current modifications, and to execute only the producers of the current version of the producer graph that currently need to be executed to maintain the consistency of the current version of the producer graph.

42. The apparatus of claim 41, wherein the producer graph structure further comprises:

an incremental execution marking structure to assist the producer graph execution module with tracking which producers in the current version of the producer graph need to be reexecuted due to any current modifications.

43. The apparatus of claim 41, further comprising:

an override log, coupled to the override producer output module and the producer graph execution module, to collect multiple overrides for batch processing.

44. The apparatus of claim 41, wherein the override producer output module is also to receive indications that one or more overridden outputs are to be unoverriden.

45. The apparatus of claim 1, wherein the runtime further comprises:

a command log, coupled to the automated producer graph generation module, to collect multiple commands together for batch processing.

46. The apparatus of claim 1, wherein each producer'"'"'s method is a method of a class of that producer'"'"'s instance.

47. The apparatus of claim 46, wherein the producer dependency declarations are pan of class definitions for classes in the object-oriented code.

48. The apparatus of claim 1, wherein any method may have one of said producer dependency declarations.

49. The apparatus of claim 1, wherein the runtime replaces the need for manual invocation sequencing code, and wherein the method of each of the producers is a transformation method and the runtime discovers sequencing for these transformation methods from the producer dependency declarations.

50. The apparatus of claim 1, wherein end nodes of the producer graph are independent producers.

51. The apparatus of claim 1, wherein the runtime further comprises:

an instance tracking structure, coupled to automated producer graph generation module and the producer graph execution module, to store references to the instances of producers; and

a method tracking structure, coupled to the automated producer graph generation module and the producer graph execution module, to store references to the methods of producers and information regarding their producer dependency declarations.

52. The apparatus of claim 51, wherein the runtime further comprises:

a new instance module, coupled to said instance tracking structure, to receive the designation of and to instantiate, if necessary, the currently selected producer of interest;

a class tracking structure to track references to classes; and

a new class module, coupled to the class tracking structure, to load and introspect class definitions.

53. The apparatus of claim 1, wherein the runtime further comprises:

a producer graph viewer module to graphically display a representation of the current producer graph.

54. The apparatus of claim 1, wherein the runtime further comprises:

a configurable interactive producer output layout graphical user interface module to graphically display outputs from and allow interaction with the producer graph.

55. The apparatus of claim 1, wherein the producer graph execution module includes:

a dynamic dependencies module to resolve any dynamic producer dependencies, wherein each producer dependency declaration may include a dynamic producer dependency, wherein dynamic producer dependencies cause the runtime to dynamically select the set of zero or more producers the producer dependency declaration identifies during run time, and wherein the dynamic selection can cause the selection of different producers for the set during different executions of the producer graph.

56. The apparatus of claim 55, wherein the dynamic producer dependencies include contingent producer dependencies, wherein contingent producer dependencies are dependencies on dependency determination producers that themselves are dependent on the output of one or more other producers.

57. The apparatus of claim 55, wherein the dynamic producer dependencies includes subscriptions, wherein subscriptions identify criteria by which producers are compared to determine if they are trigger producers, wherein subscriptions identify dependencies on trigger producers.

58. The apparatus of claim 57, wherein some of said subscriptions are absorbing subscriptions, wherein absorbing subscriptions cause the runtime to dynamically include any trigger producers in the set of zero or more producers the producer dependency declaration identifies during run time.

59. The apparatus of claim 57, wherein some of said subscriptions are sticky subscriptions, wherein sticky subscriptions also identify characteristics for parent producers, and wherein sticky subscriptions cause the runtime, for each trigger producer located, to instantiate a parent producer meeting the identified characteristics and include it in the producer graph as having a producer dependency on that trigger producer.

60. The apparatus of claim 1, wherein some of the zero or more producers are dependency determination producers whose execution returns identifications of dependencies of producers on each other.

61. The apparatus of claim 60, wherein execution of some of the dependency determination producers return upwardly declared dependencies.

62. The apparatus of claim 1, wherein at least some of the dependencies represented by the producer graph are designated as argument dependencies and field dependencies, wherein argument dependencies cause the runtime to map outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

63. The apparatus of claim 1, wherein at least some of the dependencies represented by the producer graph are designated as sequencing only dependencies, wherein sequencing only dependencies require outputs that need to be provided, if any, from child producers to parent producers occur through code in the method of the child producer to write the output to a given mechanism and code in the method of the parent producer to read that output from the given mechanism.

64. The apparatus of claim 1, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for each producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

65. The apparatus of claim 64, wherein the instances are instances of a plurality of classes, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

66. The apparatus of claim 64, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

67. The apparatus of claim 1, wherein at least some of said producer dependency declarations include upwardly declared dependencies.

68. The apparatus of claim 1, wherein at least some of said producer dependency declarations include downwardly declared dependencies.

69. The apparatus of claim 1, wherein at least some of said producer dependency declarations include both downwardly and upwardly declared dependencies.

70. The apparatus of claim 1, wherein said automated producer graph generation module is responsive to new producer commands, and wherein said producer graph execution module is responsive to execute commands.

2-35. -35. (canceled)

71. An apparatus for executing object-oriented code, said apparatus comprising:

a runtime that interprets producer dependency declarations for methods in the object-oriented code, said producer dependency declarations identify at run time a set of zero or more producers, where a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, wherein each producer'"'"'s method is a method of a class of that producer'"'"'s instance, wherein the producer dependency declarations are part of class definitions for classes in the object-oriented code, and wherein at least some of said producer dependency declarations include downwardly declared dependencies, the runtime including,

an automated producer graph generation module to receive a designation of a producer of interest, to add the producer of interest as part of a current producer graph, and to automatically generate a remainder of the current producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the current producer graph,

a producer graph structure, coupled to the automated producer graph generation module, to the current producer graph and a current output of each of the producers in the current producer graph, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, and wherein the producer key for a given producer is based on at least the instance key and the method key of that producer'"'"'s instance and method; and

a producer graph execution module, coupled to the producer graph structure, to execute the producers in the current producer graph in the order indicated by the current producer graph, wherein the current producer graph represents appropriate sequencing of execution as identified by the producer dependency declarations of the methods of the producers in the current producer graph, and wherein execution of each producer results in the method of the producer being executed on the instance of the producer, said producer graph execution module including,

a dynamic dependencies module to resolve any dynamic producer dependencies, wherein each producer dependency declaration may include a dynamic producer dependency, wherein dynamic producer dependencies cause the runtime to dynamically select the set of zero or more producers the producer dependency declaration identifies during run time, wherein the dynamic selection can cause the selection of different producers for the set during different executions of the current producer graph, wherein the dynamic producer dependencies include contingent producer dependencies, and wherein contingent producer dependencies are dependencies on dependency determination producers that themselves are dependent on the output of one or more other producers.

72. The apparatus of claim 71, wherein the runtime further comprises:

a producer graph viewer module to graphically display a representation of the current producer graph.

73. The apparatus of claim 71, wherein the runtime further comprises:

a configurable interactive producer output layout graphical user interface module to graphically display outputs from and allow interaction with the current producer graph.

74. The apparatus of claim 71, wherein the dynamic producer dependencies includes subscriptions, wherein subscriptions identify criteria by which producers are compared to determine if they are trigger producers, wherein subscriptions identify dependencies on trigger producers.

75. The apparatus of claim 74, wherein some of said subscriptions are absorbing subscriptions, wherein absorbing subscriptions cause the runtime to dynamically include any trigger producers in the set of zero or more producers the producer dependency declaration identifies during run time.

76. The apparatus of claim 74, wherein some of said subscriptions are sticky subscriptions, wherein sticky subscriptions also identify characteristics for parent producers, and wherein sticky subscriptions cause the runtime, for each trigger producer located, to instantiate a parent producer meeting the identified characteristics and include it in the current producer graph.

77. The apparatus of claim 71, wherein some of the producers are dependency determination producers whose execution returns identifications of dependencies of producers on each other.

78. The apparatus of claim 77, wherein execution of some of the dependency determination producers return upwardly declared dependencies.

79. The apparatus of claim 71, wherein at least some of the producer dependency declarations include one or more of an argument dependency and a field dependency, wherein argument dependencies cause the runtime to map outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

80. The apparatus of claim 71, wherein class keys are used to distinguish the classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

81. The apparatus of claim 71, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

82. The apparatus of claim 71, wherein said automated producer graph generation module is to receive multiple designations of producers of interest and is to automatically generate multiple current producer graphs, and wherein said producer graph execution module is responsive to global execute commands that each cause all current producer graphs to be executed.

83. A method for executing object-oriented code, said method comprising:

instantiating a producer with an output that is currently of interest, wherein the object-oriented code includes methods and producer dependency declarations, wherein the producer dependency declaration for a given method identifies a set of zero or more producers, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance;

responsive to said instantiating, adding the producer of interest as part of a current producer graph;

attempting to automatically generate a remainder of the current producer graph through linking, and instantiation as necessary, of other producers based on the producer dependency declarations of the methods of the producers already in the current producer graph; and

executing the producers in the current producer graph to determine the current output for said producer of interest.

84. The method of claim 83, wherein said attempting to automatically generate further comprises:

attempting to automatically discover and build, from producer dependency declarations in said object-oriented code, the current producer graph representing direct input to output relationships of producers needed to generate a current value of the set of one or more inputs to the producer of interest, wherein a current output of each of the producers in the current producer graph is a direct input to another one or more of the producers in the current producer graph and/or the producer of interest.

85. The method of claim 83, wherein said executing the producers in the current producer graph further comprises:

automatically generating additional pans of the current producer graph through the execution of some of the producers of the current producer graph that return identifications of dependencies of other producers on each other to be added to the current producer graph.

86. The method of claim 83, wherein said executing includes:

resolving any dynamic producer dependencies, wherein each producer dependency declaration may include a dynamic producer dependency, wherein dynamic producer dependencies cause the runtime to dynamically select the set of zero or more producers the producer dependency declaration identifies during run time.

87. The method of claim 86, wherein the dynamic producer dependencies include contingent producer dependencies, wherein contingent producer dependencies are dependencies on dependency determination producers that themselves are dependent on the output of one or more other producers.

88. The method of claim 86, wherein the dynamic producer dependencies includes subscriptions, wherein subscriptions identify criteria by which producers are compared to determine if they are trigger producers, wherein subscriptions identify dependencies for trigger producers.

89. The method of claim 88, wherein some of said subscriptions are absorbing subscriptions, wherein absorbing subscriptions cause dynamic inclusion of any trigger producers in the set of zero or more producers the producer dependency declaration identifies.

90. The method of claim 88, wherein some of said subscriptions are sticky subscriptions, wherein sticky subscriptions also identify characteristics for parent producers, and wherein sticky subscriptions cause, for each trigger producer located, instantiation of a parent producer meeting the identified characteristics and inclusion of it in the current producer graph as having a producer dependency on that trigger producer.

91. The method of claim 83, wherein said attempting to automatically generate further comprises:

instantiating any instances of the producers that have not yet been instantiated; and

instantiating the producers that have not yet been instantiated.

92. The method of claim 83, wherein said attempting to automatically generate further comprises:

loading any classes of the instances of the producers that have not yet been loaded; and

introspecting the class definitions of the classes that have not yet been introspected, including the producer dependency declarations statements contained therein.

93. The method of claim 92, wherein said attempting to automatically generate includes:

discovering and building into the current producer graph one of the producers for which the class of the instance of the producer was already loaded and introspected prior to said attempting, the instance of the producer was already instantiated prior to said attempting, and the producer was already instantiated prior to said attempting.

94. The method of claim 83 further comprising:

graphically displaying a representation of the current producer graph.

95. The method of claim 83, further comprises:

graphically displaying outputs from and allowing interaction with the current producer graph.

96. The method of claim 83 further comprising:

storing a current output of the producers of the current producer graph;

overriding the current output of one or more of the producers of the current producer graph; and

reexecuting, according to the current producer graph and the overriding and the stored current output of those of the producers that are not directly or indirectly affected by said overriding, only those of said producers that are affected, directly or indirectly, by said overriding to determine their current output.

97. The method of claim 96, wherein those of said producers that are affected are not all of the producers in the current producer graph.

98. The method of claim 96 further comprising:

unoverriding the override; and

reexecuting, according to the current producer graph and the unoverriding and the stored current output of those of the producers that are not directly or indirectly affected by said unoverriding, only those of said producers that are affected, directly or indirectly, by said unoverriding to determine their current output.

99. The method of claim 83, wherein at least some of the dependencies declared by the producer dependency declarations are designated as argument dependencies and field dependencies, wherein argument dependencies cause the mapping of outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

100. The method of claim 83, wherein at least some of the dependencies declared by the producer dependency declarations are designated as sequencing only dependencies, wherein sequencing only dependencies require outputs that need to be provided, if any, from child producers to parent producers occur through code in the method of the child producer to write the output to a given mechanism and code in the method of the parent producer to read that output from the given mechanism.

101. The method of claim 83, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for a given producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

102. The method of claim 101, wherein the instances are instances of a plurality of classes, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

103. The method of claim 101, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

104. The method of claim 83, wherein at least some of said producer dependency declarations include upwardly declared dependencies.

105. The method of claim 83, wherein at least some of said producer dependency declarations include downwardly declared dependencies.

106. The method of claim 83, wherein at least some of said producer dependency declarations include both downwardly and upwardly declared dependencies.

107. The method of claim 83, wherein said instantiating is performed responsive to a new producer command and said executing is performed responsive to a global execute command.

108. A method for executing object-oriented code, said method comprising:

receiving an indication of a producer of interest, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance;

automatically generating and executing a producer graph based on said producer of interest and producer dependency declaration statements for methods, wherein said producer graph includes a target subgraph that includes said producer of interest and a plurality of levels of other producers, said automatically generating and executing including, iteratively performing the following until source producers are reached,

discovering, building and executing a decision subgraph of producers based on the producer dependency declaration statement of the method of one of the producers already in the target subgraph, and

adding to said target subgraph a set of one or more of the other producers returned by said decision subgraph, and

executing the producers in the target subgraph sequenced as indicated by the target subgraph, wherein execution of each producers results in the method of the producer being executed on the instance of the producer.

109. The method of claim 108, wherein at least one producer is part of both the target subgraph and one of the decision subgraphs.

110. The method of claim 108, wherein a first of the decision subgraphs includes a root that is a dependency determination producer and includes nodes at least some of which are standard producers.

111. The method of claim 108, wherein the target subgraph has a root that is a standard producer.

112. The method of claim 108, wherein at least one of the decision subgraphs returns a subscription.

113. The method of claim 112, wherein the subscription is an absorbing subscription that indicates absorbing subscription criteria for trigger producers.

114. The method of claim 112, wherein the subscription is a sticky subscription that indicates sticky subscription criteria for trigger producers and sticky subscription characteristics for a parent producer to be created.

115. The method of claim 108, wherein at least one of the decision subgraphs returns an upwardly declared producer dependency.

116. The method of claim 108, wherein at least some of the producer dependency declaration statements identify one or more of an argument dependency and a field dependency, wherein argument dependencies cause the mapping of outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

117. The method of claim 108, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for each producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

118. The method of claim 117, wherein the instances are instances of a plurality of classes, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

119. The method of claim 117, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

120. The method of claim 108 further comprising:

graphically displaying a representation of the producer graph.

121. The method of claim 108, further comprises:

graphically displaying outputs from and allowing interaction with the producer graph.

122. The method of claim 108, further comprising:

receiving an execute command after said receiving the indication of the producer of interest and prior to said automatically generating and executing.

123. An apparatus for executing object-oriented code, said apparatus comprising:

a runtime to automatically generate and execute a producer graph based on a producer of interest and producer dependency declaration statements for methods, wherein a producer is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, said runtime including the following iteratively related modules,

an automated producer graph generation module to receive a designation of said producer of interest, to add said producer of interest to a target subgraph of said producer graph, and to automatically generate a plurality of levels of other producers in said target subgraph through automatically discovering and building decision subgraphs based on the producer dependency declaration statements of the methods of the producers currently in the target subgraph, and

a producer graph execution module to execute the producers in the producer graph, wherein execution of each producer results in the method of the producer being executed on the instance of the producer, and wherein execution of each of a plurality of the decision subgraphs adds at least another producer to said target subgraph.

124. The apparatus of claim 123, wherein at least one producer is part of both the target subgraph and one of the decision subgraphs.

125. The apparatus of claim 123, wherein a first of the decision subgraphs includes a root that is a dependency determination producer and includes nodes at least some of which are standard producers.

126. The apparatus of claim 123, wherein the target subgraph has a root that is a standard producer.

127. The apparatus of claim 123, wherein at least one of the decision subgraphs returns a subscription.

128. The apparatus of claim 127, wherein the subscription is an absorbing subscription that indicates absorbing subscription criteria for trigger producers.

129. The apparatus of claim 127, wherein the subscription is a sticky subscription that indicates sticky subscription criteria for trigger producers and sticky subscription characteristics for a parent producer to be created.

130. The apparatus of claim 123, wherein at least one of the plurality of decision subgraphs returns an upwardly declared producer dependency.

131. The apparatus of claim 123, wherein at least some of the producer dependency declaration statements identify one or more of an argument dependency and a field dependency, wherein argument dependencies cause the mapping of outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

132. The apparatus of claim 123, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for each producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

133. The apparatus of claim 132, wherein the instances are instances of a plurality of classes, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

134. The apparatus of claim 132, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

135. The apparatus of claim 123, wherein the runtime further comprises:

a producer graph viewer module to graphically display a representation of the current producer graph.

136. The apparatus of claim 123, wherein the runtime further comprises:

a configurable interactive producer output layout graphical user interface module to graphically display outputs from and allow interaction with the producer graph.

137. The apparatus of claim 123, wherein said automated producer graph generation module is responsive to new producer commands, and wherein said producer graph execution module is responsive to execute commands.

138. A machine-storage medium that provides object-oriented code including:

a plurality of class definitions each including,

a set of one or more fields,

a set of one or more methods, and

a producer dependency declaration for each of said set of methods, wherein the producer dependency declaration for a given one of said methods is used at runtime to identify a set of zero or more producers, wherein a producer is a runtime instantiatable construct that includes at least an instance of one of the plurality of classes at runtime and a method of that class; and

wherein a first producer has a contingent producer dependency as follows,

a first method of said sets of methods is a property method,

a second method of said sets of methods has a producer dependency declaration statement that identifies a property producer based on said property method, and has code to select between a second and third producer based on the output of said property producer, and

a third method of said sets of methods has a producer dependency declaration statement that identifies a dependency determination producer based on said second method, wherein said first producer is based on said third method and is to have a producer dependency on whichever of said second and third producer the dependency determination producer is currently returning.

139. The machine-storage medium of claim 138, wherein:

a fourth producer has a subscription dependency on a trigger producer as follows,

a fourth method of said sets of methods, wherein said fourth producer is based on said fourth method,

a fifth method of said sets of methods that has code that indicates a set of subscription criteria for trigger producers, wherein a subscription producer is based on said fifth method, and

a sixth method of said sets of methods, wherein said trigger producer is based on said sixth method and said subscription dependency is created because said trigger producer meets said set of subscription criteria.

140. The machine-storage medium of claim 139, wherein said set of subscription criteria is absorbing subscription criteria, and wherein said fourth method has a producer dependency declaration that identifies said subscription producer.

141. The machine-storage medium of claim 139, wherein said set of subscription criteria is sticky subscription criteria, wherein said fifth method also includes code that indicates a set of sticky subscription characteristics for parent producers, wherein said trigger producer meets said sticky subscription criteria, and wherein said fourth producer meets said sticky subscription characteristics and was instantiated as a result of said subscription dependency.

142. The machine-storage medium of claim 138, wherein at least one of said producer dependency declarations includes a strongly constrained argument dependency.

143. The machine-storage medium of claim 138, wherein at least one of said producer dependency declarations includes a strongly constrained field dependency.

144. The machine-storage medium of claim 138, wherein:

a fourth producer has a producer dependency on a fifth producer as follows,

a fourth method of said sets of methods, wherein said fourth producer is based on said fourth method,

a fifth method of said sets of methods that has code that upwardly declares a producer dependency, and

a sixth method of said sets of methods has a producer dependency declaration that identifies a dependency determination producer based on said fifth method, wherein said fifth producer is based on said sixth method and has a producer dependency on said dependency determination producer that returns the producer dependency of the fourth producer on the fifth producer.

145. The machine-storage medium of claim 138, wherein method keys are used to distinguish said sets of methods, instance keys are used to distinguish instances of said plurality of class definitions, and producer keys are used to distinguish producers, wherein the producer key for each producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

146. The machine-storage medium of claim 145, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

147. The machine-storage medium of claim 145, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

148. A machine-storage medium that provides object-oriented code including:

a program having a plurality of class definitions each including,

a set of one or more fields,

a set of one or more methods, and

a producer dependency declaration for each of said set of methods, wherein the producer dependency declaration for a given one of said methods is used at run time to identify a set of zero or more producers, wherein a producer is a runtime instantiatable construct that includes at least an instance of one of the plurality of classes at run time and a method of that class; and

wherein the method of each of the producers is a transformation method and the program does not include manual invocation sequencing code, but instead relies on a runtime to automatically discover sequencing for the transformation methods from the producer dependency declarations.

149. The machine-storage medium of claim 148, wherein at least some of said producer dependency declarations include a dynamic producer dependency, wherein dynamic producer dependencies cause the set of zero or more producers to be dynamically selected during run time.

150. The machine-storage medium of claim 149, wherein the dynamic producer dependencies include contingent producer dependencies, wherein contingent producer dependencies are dependencies on dependency determination producers that themselves are dependent on the output of one or more other producers.

151. The machine-storage medium of claim 149, wherein the dynamic producer dependencies includes subscriptions, wherein subscriptions identify criteria by which producers are compared to determine if they are trigger producers, wherein subscriptions identify dependencies for trigger producers.

152. The machine-storage medium of claim 151, wherein some of said subscriptions are absorbing subscriptions, wherein absorbing subscriptions cause dynamic inclusion of any trigger producers in the set of zero or more producers the producer dependency declaration identifies.

153. The machine-storage medium of claim 151, wherein some of said subscriptions are sticky subscriptions, wherein sticky subscriptions also identify characteristics for parent producers, and wherein sticky subscriptions cause, for each trigger producer located, instantiation of a parent producer meeting the identified characteristics and inclusion of it in a producer graph as having a producer dependency on that trigger producer.

154. The machine-storage medium of claim 148, wherein at least some of the dependencies declared by the producer dependency declarations are designated as argument dependencies and field dependencies, wherein argument dependencies cause the mapping of outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

155. The machine-storage medium of claim 148, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for a given producer is based on at least the instance key and the method key of that producer'"'"'s instance and method.

157. The machine-storage medium of claim 155, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

158. The machine-storage medium of claim 148, wherein at least some of said producer dependency declarations include upwardly declared dependencies.

156. The machine-storage medium 155, wherein class keys are used to distinguish said plurality of classes, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

159. A machine-storage medium having stored thereon:

a set of one or more instances of a set of one or more classes, wherein each class includes methods and producer dependency declarations for the methods, wherein each of the set of instances is associated with all of the methods of its class, and wherein the producer dependency declarations identify at run time a set of one or more dependencies between producers;

a producer graph structure having stored therein,

a plurality of producers that each is a construct instantiated at run time and that includes only one of said set of instances and only one of the methods associated with that instance,

a plurality of links representing a multiple level graph of the plurality of producers, wherein the plurality of links represent the dependencies between the producers in the producer graph identified by the producer dependency declarations for the methods included in the plurality of producers,

a producer key for each of said plurality of producers, wherein each producer key is based on at least an instance key and a method key that identify the one of said set of instances and the one of the methods associated with that instance, and

a current output of each of the plurality of producers in the producer graph; and

an instance tracking structure having stored therein a correspondence between the instance keys and the set of instances.

160. The machine-storage medium of claim 159, wherein said producer graph structure represents appropriate sequencing of execution as identified by the producer dependency declarations of the methods of the producers in the producer graph.

161. The machine-storage medium of claim 159, wherein the producer graph structure represents the direct input to output dependencies of the producers on each other from a producer of interest to those of the producers that are end nodes of the producer graph.

162. The machine-storage medium of claim 159, wherein at least some of the dependencies represented by the producer graph structure are designated as argument dependencies and field dependencies, wherein argument dependencies cause the runtime to map outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

163. The machine-storage medium of claim 159, wherein at least some of the dependencies represented by the producer graph structure are designated as sequencing only dependencies, wherein sequencing only dependencies require outputs that need to be provided, if any, from child producers to parent producers occur through code in the method of the child producer to write the output to a given mechanism and code in the method of the parent producer to read that output from the given mechanism.

164. The machine-storage medium of claim 159, wherein the producer graph structure further includes:

override producer output modifications that store for each of said plurality of producers an indication of whether that producer is overridden and the overridden output value.

165. The machine-storage medium of claim 159 further having stored thereon:

a set of class definitions written in object-oriented code for the set of classes wherein each of the producer dependency declarations includes a producer dependency declaration statement located adjacent to the one of the methods it is for.

166. The machine-storage medium of claim 159, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

167. The machine-storage medium of claim 159, wherein each producer key is also at least based on a class key that identifies the class of the instance of the producer.

168. The machine-storage medium of claim 167 further having stored thereon:

a representation of the plurality of classes loaded and introspected during run time, said representation including the results of introspecting the methods and producer dependency declarations;

a class tracking structure having stored therein a correspondence between class keys and the representation of the set of classes; and

a method tracking structure having stored therein a correspondence between method keys and the results of introspecting the methods, as well as information regarding the results of introspecting the producer dependency declarations.

169. A machine-storage medium having stored thereon:

an object-oriented source code including client code, said client code including,

a producer instantiation command that has a producer key for a producer of interest and that causes a runtime for object-oriented code to automatically discover, build, and optionally resolve a current producer graph starting from the producer of interest and having multiple levels of discovered producers, wherein each of the producers is a runtime instantiatable construct that includes at least an instance and a method associated with that instance, wherein the runtime automatically instantiates any of the producers of the current producer graph that are not yet instantiated, wherein producer keys are used to distinguish the producers, wherein method keys are used to distinguish the methods, wherein instance keys are used to distinguish the instances, and wherein the producer key for each producer is based on at least the instance key and the method key of that producer'"'"'s instance and method;

execute commands that each cause the runtime for object-oriented code to execute the current producer graph and to cache a current output for each of the producers executed in the current producer graph; and

producer output override commands that each has a producer key and an override value and that each cause the runtime for object-oriented code to override the output of the producer designated by the producer key with the override value.

170. The machine-storage medium of claim 169, wherein the runtime client further includes:

producer output unoverride commands that each has the producer key of one of the producers that has been overridden and that each cause the runtime for object-oriented code to unoveride the output of that producer.

171. The machine-storage medium of claim 169, wherein the producer instantiation command is a new producer command, and wherein the producer output override commands are set commands.

172. The machine-storage medium of claim 169, wherein the causation of the producer instantiation command and the producer output override commands is indirect through a log kept by the runtime for object-oriented code.

173. The machine-storage medium of claim 169, wherein the first of the execute commands causes an initial execution and each subsequent one of the execute commands causes an incremental execution.

174. The machine-storage medium of claim 169, wherein the runtime client further includes:

an instance instantiation command that has the instance key of the producer of interest and that causes the runtime for object-oriented code to instantiate the instance of the producer of interest.

175. The machine-storage medium of claim 169, wherein each set of one or more of the producer output override commands is followed by one of the execute commands.

176. The machine-storage medium of claim 169, wherein class keys are used to distinguish a plurality of classes of which the instances are instances, and wherein the producer key for each producer is also based on the class key of the class of that producer'"'"'s instance.

177. The machine-storage medium of claim 176, wherein the producer instantiation command causes the runtime for object-oriented code to instantiate the producer of interest by accessing the class of the producer through a class tracking structure using the class key of the producer key of the producer instantiation command, accessing the instance of the producer through an instance tracking structure using the instance key of the producer key of the producer instantiation command, and accessing a producer dependency declaration of the method of the producer through a method tracking structure using the method key of the producer key of the producer instantiation command.

178. The machine-storage medium of claim 169, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.

179. The machine-storage medium of claim 169, wherein said client code further includes:

additional producer instantiation commands that cause the runtime for object-oriented code to automatically discover, build, and optionally resolve other current producer graphs, wherein each of said execute commands cause said runtime for object-oriented code to execute all current producer graphs.

180. The machine-storage medium of claim 169, wherein said object-oriented source code also includes class definitions, wherein said class definitions include business logic expressed in methods with producer dependency declarations.

181. The machine-storage medium of claim 180, wherein the producer dependency declarations define the ties between producers during the definition of the classes that include the business logic, rather than after instances of those classes are created.

182. A method for producer output layout, said method comprising:

displaying a list including classes, with their get property methods, of producers in a producer graph and of those producer'"'"'s outputs, wherein said producer graph was automatically generated and executed based on a producer of interest and producer dependency declarations for methods of classes, wherein a producer is a runtime instantiatable construct that includes at least a class, an instance of that class, and a method of that class that is associated with that instance, wherein the producer dependency declarations of the methods of the producers in the producer graph each identified a set of zero or more of the other producers in the producer graph, wherein said producer graph includes said producer of interest and a plurality of levels of other producers;

displaying a spreadsheet having cells;

receiving mappings of a plurality of the displayed get property methods of a set of one or more of the displayed classes to cells of the spreadsheet; and

populating at least the cells of said mappings with the outputs of the corresponding get property methods of a set of one or more instances.

183. The method of claim 182, further comprising:

receiving a value for one of the automatically populated cells;

overriding the output of the producer whose output is currently populating that cell with said value;

at least incrementally executing the producer graph and updating the cells of said mapping as necessary.

184. The method of claim 182, wherein said populating further comprises:

receiving an indication of selection of the set of one or more instances.

185. The method of claim 184, wherein said receiving an indication of selection of the set of one or more instances includes receiving at least an indication of an instance key of one of the set of instances.

186. The method of claim 182, wherein said populating further comprises:

receiving an indication of selection of one of a plurality of filters to be applied to select instances that are of at least a first of said set of displayed classes, wherein each of said plurality of filters enables selection in a different way.

187. The method of claim 186, wherein said populating further comprises:

prior to said receiving the indication of selection of one of the plurality of filters, receiving a mapping of said first class to one of the cells of the spreadsheet.

188. The method of claim 187, wherein said receiving the indication of selection of one of the plurality of filters is performed through the cell of the spreadsheet to which said first class was mapped.

189. The method of claim 188, wherein said populating further comprises:

after said receiving the indication of selection of one of the plurality of filters, receiving an indication of selection of one of the instances of the first class using the selected filter through the cell of the spreadsheet to which said first class was mapped.

190. The method of claim 189, wherein said receiving the indication of selection of one of the instances of the first class further comprises:

receiving an indication of the instance key of the one of the set of instances.

191. The method of claim 182, wherein said populating further comprises:

receiving an indication of a zone defining a table, wherein said table includes a plurality of rows and columns of cells of the spreadsheet;

wherein said receiving mappings is performed to a group of cells on one edge of the table;

populating the group of cells on the one edge with the outputs of the corresponding get property methods of a first instance of a first of said set of displayed classes; and

iteratively populating each adjacent group of cells having a same orientation until the opposite edge of the table is reached with the outputs of the corresponding get property methods of another instance of said first class.

192. The method of claim 182, wherein at least one of the producer dependency declarations includes a dynamic producer dependency, wherein dynamic producer dependencies cause a dynamic selection of the set of zero or more producers the producer dependency declaration identifies during run time.

193. The method of claim 192, wherein the dynamic producer dependency is a contingent producer dependency, wherein contingent producer dependencies are dependencies on dependency determination producers that themselves are dependent on the output of one or more other producers.

194. The method of claim 192, wherein the dynamic producer returns a subscription.

195. The method of claim 194, wherein the subscription is an absorbing subscription that indicates absorbing subscription criteria for trigger producers.

196. The method of claim 194, wherein the subscription is a sticky subscription that indicates sticky subscription criteria for trigger producers and sticky subscription characteristics for the parent producer to be created.

197. The method of claim 182, wherein at least some of the producer dependency declarations identify one or more of an argument dependency and a field dependency, wherein argument dependencies cause the mapping of outputs of child producers as input parameters to parent producers, and wherein field dependencies indicate uses of fields of instances.

198. The method of claim 182, wherein class keys are used to distinguish said classes, wherein method keys are used to distinguish the methods, instance keys are used to distinguish the instances, and producer keys are used to distinguish the producers, wherein the producer key for each producer is based on at least the class key, instance key, and method key of that producer'"'"'s class, instance, and method.

199. The method of claim 198, wherein the instance key of at least some producers holds a reference to the producer'"'"'s instance.