Abstract:
A reusable expression graph system and method that generates reusable expression graphs that can be used with potentially different input parameters in order to achieve computational efficiency and ease of programming. Reusable expression graph mitigate the need to rebuild an expression for each new value. This is achieved in part by creating a node called a “parameter node.” The parameter node acts as a generic placeholder for a leaf node in the expression graph. In addition, the parameter node acts as a proxy for a bindable term of the leaf node, and the bindable term can be either a value or one or more additional expressions. The parameter node then is bound to the bindable term and the expression is evaluated with that bindable term instead of the placeholder. The parameter node created by embodiments of the reusable expression graph system and method works across many different programming languages.

Description:
BACKGROUND 
     Software developers often use functions when coding software programs. A function is a portion of code within a larger program that performs particular assignment and is relatively independent of the remainder of the code. Functions allow a developer to divide a program into sections so that those sections can be reused throughout the program for different value without the need to rewrite the program each time the values are changed. 
     In general, a function accepts a parameter as input, processes the parameter according to the function, and then returns a result. A parameter is a generic placeholder that acts as a proxy until an actual value is assigned to the parameter. Once the actual value is assigned to the parameter then the expression is evaluated with the assigned value rather than the placeholder. 
     Software developers also may use of expressions, which are a combination of functions and values. Software developers often build up expressions when they are writing programs. Based on rules of precedence and association for the particular programming language being used, an expression is computed and a value or answer is returned. This process of computing and returning a value for an expression is known as “evaluating the expression.” 
     One way in which expressions are represented so that they can be evaluated is by using expression graphs. An expression graph is a directed acyclic graph having nodes and edges. The nodes are values and operators that are connected to each other by edges. For example, assume a simple expression is created that is (A+B)*C. In order to build an expression graph for this expression nodes are created for “A,” “B,” and “C” and nodes “A” and “B” are connected by a “+” node. Moreover, a node is created for “*” and that node is placed above the “+” node and a line is drawn down to the “+” node and a line down to C. This is an expression graph representing the expression (A+B)*C. 
     Expression graphs include both operator nodes and leaf nodes. A leaf node (or external node) is a node of an expression graph that contains a value. In addition, the leaf node has zero child nodes or other nodes hanging off of them. An operator node is a node in the expression graph that performs an operation (such as addition or multiplication) on the values in the leaf nodes. In the above example, the “+” node and the “*” node are operator nodes, and the values “A,” “B,” and “C” nodes are leaf nodes. 
     SUMMARY 
     This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. 
     Embodiments of the reusable expression graph system and method reuse expression graphs with potentially different input parameters in order to achieve computational efficiency and ease of programming. In a similar way that functions allow a programmer to reuse code, embodiments of the reusable expression graph system and method allow expression graphs (and thereby expressions) to be reused without the need to rebuild the expression for each new value. 
     Embodiments of the reusable expression graph system and method include a node called a “parameter node.” This parameter node is a leaf node that can be bound to any expression node, including other leaf nodes. Thus, the parameter node is a leaf node that is a generic placeholder. Moreover, the parameter node is placeholder that is not restricted to leaf nodes but other types of nodes as well. The parameter node can act as a proxy for a bindable term of the leaf node, and the bindable term can be either a value or one or more additional expressions. The parameter node then is bound to the bindable term and the expression is evaluated with that bindable term rather than the placeholder. 
     Embodiments of the reusable expression graph system and method mitigate the instances of a developer having to rebuild an entire expression each time they wanted to change the value of a leaf node. In other words, the developer does not have to run the code to rebuild the expression every time the value of a leaf node is changed. Moreover, the parameter node created by embodiments of the reusable expression graph system and method works across many different types of programming languages. 
     It should be noted that alternative embodiments are possible, and that steps and elements discussed herein may be changed, added, or eliminated, depending on the particular embodiment. These alternative embodiments include alternative steps and alternative elements that may be used, and structural changes that may be made, without departing from the scope of the invention. 
    
    
     
       DRAWINGS DESCRIPTION 
       Referring now to the drawings in which like reference numbers represent corresponding parts throughout: 
         FIG. 1  illustrates an example of a standard expression graph  100  representing an expression c=a+b. 
         FIG. 2  is a detailed flow diagram illustrating the operational details of the generation of a parameter node for embodiments of the reusable expression graph method. 
         FIG. 3  illustrates an example of a reusable expression graph having a first parameter node “A”. 
         FIG. 4  illustrates an example of a reusable expression graph having the first parameter node “A” and a second parameter node “B”. 
         FIG. 5  illustrates an example of a reusable expression graph having a second parameter node “A”, the second leaf node, and joined by the operator node. 
         FIG. 6  illustrates an example of a reusable expression graph having the first parameter node “A”, a third parameter node “B”, and joined by the operator node. 
         FIG. 7  is a flow diagram illustrating the operation of embodiments of the reusable expression graph system and method shown in  FIGS. 2-6 . 
         FIG. 8  illustrates an example of a suitable computing system environment in which embodiments of the reusable expression graph system and method shown in  FIGS. 2-7  may be implemented. 
     
    
    
     DETAILED DESCRIPTION 
     In the following description of embodiments of the reusable expression graph system and method reference is made to the accompanying drawings, which form a part thereof, and in which is shown by way of illustration a specific example whereby embodiments of the reusable expression graph system and method may be practiced. It is to be understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the claimed subject matter. 
     I. Overview 
     Embodiments of the reusable expression graph system and method build and evaluate expressions represented by expression graphs.  FIG. 1  illustrates an example of a standard expression graph  100  representing the expression c=a+b. As shown in  FIG. 1 , the standard expression graph  100  includes a first node  110  containing the hard value “a,” and a second node  120  containing the hard value “b.” The first node  110  and the second node  120  are joined by an operator node  130  representing the addition operator. Note that in this example the “+” sign is an operator and the value “a” and the value “b” are operands. 
     For all of the reasons that functions are used in programming languages, it is also desirable to also use functions in embodiments of the reusable expression graph system and method. Just as functions allow a programmer to reuse code, embodiments of the reusable expression graph system and method facilitate the reuse of expressions represented by expression graphs. In a standard programming language a function uses a parameter as a generic placeholder. Thus, each time the function is reused all that is necessary is for the programmer to give a value to the placeholder and then the function will be evaluated with that value instead of the placeholder. Embodiments of the reusable expression graph system and method use this idea of a placeholder and apply it to expression graphs to make the expression graph reusable. 
     II. Operational Details 
     The operational details of embodiments of the reusable expression graph system and method now will be discussed. 
     II.A. Parameter Node 
     Embodiments of the reusable expression graph system and method create and use a node called a “parameter node.” The parameter node allows an expression graph to be reused. A parameter node is a generic placeholder in an expression graph that allows for a bindable term to be used in place of the parameter node when the expression is evaluated. The bindable term can be a hard value, another expression, another parameter node, or any combination thereof. The bindable term is bound to the parameter node and the expression is evaluated using that bindable term. 
     Moreover, the expression can be reevaluated with a different bindable term bound to the parameter node. In other words, if a user builds an expression that contains a parameter node as a leaf, the expression can be reused with different values (or bindings) for the parameter. The advantages of embodiments of the reusable expression graph system and method is that a developer does not have to rebuild the entire expression every time they wanted to change the value of a leaf node of the expression graph representing that expression. In other words, embodiments of the reusable expression graph system and method alleviate the developer having to run the code to rebuild the expression every time the value of an expression graph leaf node is changed. Reuse not only saves building the expression, but also allows the reuse of some of the evaluation of the expression. For example in the case where expressions are used to generate code, parameter nodes allow the generated code to be saved and reused for different parameter bindings. In addition, expression graphs can be embedded in various languages through libraries. Parameter nodes used by embodiments of the reusable expression graph system and method allow the reuse of these expression graphs and can be used in any programming language in which the expression graph can be used. 
     The parameter node is a special kind of leaf node. In the example above shown in  FIG. 1 , the user could use a parameter node in place of the second leaf node  120 . The parameter node allows a user to set the value of the parameter node to different values whenever she wants to evaluate the expression. Those different values are used in place of that parameter node each time the expression is evaluated. In some embodiments of the reusable expression graph system and method, the parameter node has a “type,” meaning that it can be specified whether the parameter node takes a floating point value or an integer value. In alternate embodiments of the reusable expression graph system and method, the value of the parameter node can have any type. 
     The parameter node also allows the expression to be reused, without having to build up the expression again just to change a value (such as the second leaf node  120  shown in  FIG. 1 ). Embodiments of the reusable expression graph system and method allow expression graphs to be built up. In effect the expression graphs are functional. The value at the parameter node can be changed easily without rebuilding the expression. Moreover, each time the user adds a node to the expression this creates a new expression, while the old expression included in the new expression does not change. This is not true of standard non-functional programming languages. Moreover, embodiments of the reusable expression graph system and method can be easily embedded in virtually any programming language. 
     II.B. Generating a Parameter Node 
       FIG. 2  is a detailed flow diagram illustrating the operational details of the generation of a parameter node for embodiments of the reusable expression graph method. In general, a parameter node is generated or created by a user when building an expression to make the expression graph reusable. More specifically, as shown in  FIG. 2 , embodiments of the reusable expression graph method allow a user to select a parameter node when an expression is being built (box  200 ). Typically, this selection is done by a user, although in some embodiments it may be performed automatically. 
     Next, embodiments of the reusable expression graph method create an expression graph containing the parameter node (box  210 ). As noted above, this parameter node acts as a generic placeholder on the expression graph.  FIG. 3  illustrates an example of a reusable expression graph  300  having a first parameter node, P 1   310 . By comparing  FIG. 3  with  FIG. 1 , it can be seen that first parameter node, P 1310  is used instead of the first node  110 . In addition, the operator node  130  still joins the first parameter node P 1   310  and the second node  120 . This reusable expression graph  300  represents the expression c=P 1 +b, where P 1  is represented by the first parameter node, P 1   310  and b is represented by the second node  120 . 
     Embodiments of the reusable expression graph system and method also allow the use of as many parameter nodes as there are leaf nodes in an expression graph.  FIG. 4  illustrates an example of a reusable expression graph  400  having the first parameter node, P 1   310  and a second parameter node, P 2   410 . The first parameter node, P 1310  and the second parameter node P 2   410  are joined by the operator node  130 . The reusable expression graph  400  in this case represents the expression given by c=P 1 +P 2 , where again P 1  is represented by the first parameter node P 1   310  and P 2  is represented by the second parameter node, P 2   410 . 
     Referring back to  FIG. 2 , a decision then is made (typically by the user) on how to bind the parameter node (box  220 ). In general, the parameter node can be bound to virtually anything. In some embodiments the user selects what values or expressions to bind to the parameter node. The parameter node does not have to be bound to a leaf value. The parameter can be bound to a leaf, which would be a hard value, or a two-dimensional array, or it can be bound to another expression in the form of another directed acyclic graph. One way in which the parameter node can be bound is to a single hard value (boxes  230 ). By “hard value” it is meant a value that is a constant. The value may a single value or a multi-dimensional array of values. For example, a single hard value may be the number “8”, while one-dimensional arrays of numbers and two-dimensional arrays of numbers may also be used and included in the phrase “hard value.” 
     Another way in which the parameter node can be bound is to bind the parameter node to an expression that contains a plurality of hard values (box  240 ).  FIG. 5  illustrates an example of a reusable expression graph  500  having a third parameter node, P 3   510 , the second node  120 , and joined by the operator node  130 . The reusable expression graph  500  in this case represents the expression given by c=P 3 +b, where P 3  is represented by the third parameter node, P 3   510  and b is represented by the second node  120 . In this example shown in  FIG. 5 , P 3 =(a*b). This means that the third parameter node, P 3510  is bound to an expression that contains a plurality of hard values, or (a*b). 
     Still another way in which the parameter node can be bound is to bind the parameter node to an expression that contains an embedded parameter (box  250 ).  FIG. 6  illustrates an example of a reusable expression graph  600  having the first parameter node, P 1   310 , a fourth parameter node, P 4   610 , and joined by the operator node  130 . The reusable expression graph  600  in this case represents the expression given by c=P 1 +P 4 , where P 1  is represented by the first parameter node, P 1   310  and P 4  is represented by the fourth parameter node, P 4   610 . In this example shown in  FIG. 6 , the parameter node contains another parameter node. In particular, P 4 =(a*P 5 ). This means that the fourth parameter node, P 4   610  is bound to an expression that contains an embedded parameter node, or (a*P 5 ). Once the parameter node is bound in the selected manner, embodiments of the reusable expression graph method output the bound parameter node (box  260 ). 
     II.C. Using the Parameter Node 
     Embodiments of the reusable expression graph system and method not only create or generate the parameter node as a replacement for a leaf node, but also use the parameter node to obtain a reusable expression graph.  FIG. 7  is a flow diagram illustrating the operation of embodiments of the reusable expression graph system and method shown in  FIGS. 2-6 . In general, embodiments of the reusable expression graph system and method create a parameter node for an expression graph and use the parameter node in evaluating the expression represented by the expression graph. In particular, referring to  FIG. 7 , the method begins by creating or generating a parameter node (box  700 ). This process of generating the parameter node is described in above in the discussion about  FIG. 2 . Next, a user generates an expression using the parameter node (box  710 ). This expression can be represented by an expression graph, and the expression graph contains the parameter node. 
     Embodiments of the reusable expression graph system and method then bind the parameter node to a first bindable term (box  720 ). The expression then is evaluated using the first bindable term in place of the parameter node (box  730 ). In this way the expression graph is reusable because the expression behaves like a function. The values currently bound are the parameters with which the expression is evaluated. 
     The expression graph then is reused by binding the parameter node to a second bindable term (box  740 ). The expression then is evaluated using the second bindable term (box  750 ). In this manner, the reusable expression graph can be reused by binding different values to the parameter node. The expression then can be evaluated without the need to rebuild the expression each time the value is changed. 
     III. Exemplary Operating Environment 
     Embodiments of the reusable expression graph system and method are designed to operate in a computing environment. The following discussion is intended to provide a brief, general description of a suitable computing environment in which embodiments of the reusable expression graph system and method may be implemented. 
       FIG. 8  illustrates an example of a suitable computing system environment in which embodiments of the reusable expression graph system and method shown in  FIGS. 2-7  may be implemented. The computing system environment  800  is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing environment  800  be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment. 
     Embodiments of the reusable expression graph system and method are operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well known computing systems, environments, and/or configurations that may be suitable for use with embodiments of the reusable expression graph system and method include, but are not limited to, personal computers, server computers, hand-held (including smartphones), laptop or mobile computer or communications devices such as cell phones and PDA&#39;s, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like. 
     Embodiments of the reusable expression graph system and method may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform particular tasks or implement particular abstract data types. Embodiments of the reusable expression graph system and method may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices. Still further, the aforementioned instructions may be implemented, in part or in whole, as hardware logic circuits, which may or may not include a processor. With reference to  FIG. 8 , an exemplary system for embodiments of the reusable expression graph system and method includes a general-purpose computing device in the form of a computer  810 . 
     Components of the computer  810  may include, but are not limited to, a processing unit  820  (such as a central processing unit, CPU), a system memory  830 , and a system bus  821  that couples various system components including the system memory to the processing unit  820 . The system bus  821  may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus. 
     The computer  810  typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by the computer  810  and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes volatile and nonvolatile removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. 
     Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the computer  810 . By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media. 
     The system memory  830  includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM)  831  and random access memory (RAM)  832 . A basic input/output system  833  (BIOS), containing the basic routines that help to transfer information between elements within the computer  810 , such as during start-up, is typically stored in ROM  831 . RAM  832  typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit  820 . By way of example, and not limitation,  FIG. 8  illustrates operating system  834 , application programs  835 , other program modules  836 , and program data  837 . 
     The computer  810  may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only,  FIG. 8  illustrates a hard disk drive  841  that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive  851  that reads from or writes to a removable, nonvolatile magnetic disk  852 , and an optical disk drive  855  that reads from or writes to a removable, nonvolatile optical disk  856  such as a CD ROM or other optical media. 
     Other removable/non-removable, volatile/nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive  841  is typically connected to the system bus  821  through a non-removable memory interface such as interface  840 , and magnetic disk drive  851  and optical disk drive  855  are typically connected to the system bus  821  by a removable memory interface, such as interface  850 . 
     The drives and their associated computer storage media discussed above and illustrated in  FIG. 8 , provide storage of computer readable instructions, data structures, program modules and other data for the computer  810 . In  FIG. 8 , for example, hard disk drive  841  is illustrated as storing operating system  844 , application programs  845 , other program modules  846 , and program data  847 . Note that these components can either be the same as or different from operating system  834 , application programs  835 , other program modules  836 , and program data  837 . Operating system  844 , application programs  845 , other program modules  846 , and program data  847  are given different numbers here to illustrate that, at a minimum, they are different copies. A user may enter commands and information (or data) into the computer  810  through input devices such as a keyboard  862 , pointing device  861 , commonly referred to as a mouse, trackball or touch pad, and a touch panel or touch screen (not shown). 
     Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, radio receiver, or a television or broadcast video receiver, or the like. These and other input devices are often connected to the processing unit  820  through a user input interface  860  that is coupled to the system bus  821 , but may be connected by other interface and bus structures, such as, for example, a parallel port, game port or a universal serial bus (USB). A monitor  891  or other type of display device is also connected to the system bus  821  via an interface, such as a video interface  890 . In addition to the monitor, computers may also include other peripheral output devices such as speakers  897  and printer  896 , which may be connected through an output peripheral interface  895 . 
     The computer  810  may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer  880 . The remote computer  880  may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer  810 , although only a memory storage device  881  has been illustrated in  FIG. 8 . The logical connections depicted in  FIG. 8  include a local area network (LAN)  871  and a wide area network (WAN)  873 , but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet. 
     When used in a LAN networking environment, the computer  810  is connected to the LAN  871  through a network interface or adapter  870 . When used in a WAN networking environment, the computer  810  typically includes a modem  872  or other means for establishing communications over the WAN  873 , such as the Internet. The modem  872 , which may be internal or external, may be connected to the system bus  821  via the user input interface  860 , or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer  810 , or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,  FIG. 8  illustrates remote application programs  885  as residing on memory device  881 . It will be appreciated that the network connections shown are exemplary and other means of establishing a communications link between the computers may be used. 
     The foregoing Detailed Description has been presented for the purposes of illustration and description. Many modifications and variations are possible in light of the above teaching. It is not intended to be exhaustive or to limit the subject matter described herein to the precise form disclosed. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims appended hereto.