Delay formula calculations
Through delay formula computing technology, the calculation tasks at the start of the software application are delayed until the user accesses the required functions, solving the problem that resource-intensive computing tasks affect the user experience, achieving faster startup speed and higher user experience.
Patent Information
- Application Number
- CN202380052965.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2022-11-03
- Filing Date
- 2023-07-12
- Publication Date
- 2025-02-28
AI Technical Summary
Many computing tasks are resource- and time-intensive when software applications start, but users may never use these features, resulting in a compromised user experience.
Through delay formula calculation technology, delay the programming formula calculation in the dependency chart until the specific functions required are accessed by the user, avoiding unnecessary calculations at startup.
It improves software startup speed, reduces resource consumption, improves user experience, and ensures that calculations and data retrieval are only performed when users actually need it.
Smart Images
Figure CN119547048A_ABST
Abstract
Description
Background Art
[0001] When a software application is launched, the software application may perform various calculations during the startup phase, which may reduce the user experience of waiting for such calculations (e.g., calculating the results of a formula) to complete. For example, an application may access a database to calculate certain global variables using command logic at startup, such as calculating user interface parameters for a video display component of the application (e.g., the size of a video player window to be presented in a mobile device). In some applications, these calculations (or at least several such calculations) are resource and time intensive, and many of the calculations are never needed by the user after startup (e.g., the user never executes a video player function). Summary of the invention
[0002] In some aspects, the technology described herein relates to a method comprising: executing software that includes a set of programming formulas, wherein the set includes a first programming formula that is defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a deferred formula calculation request program code in the software to obtain a result of the first programming formula; during execution of the software, identifying the second programming formula based on a traversal within an associated dependency graph of the first programming formula; during execution of the software, calculating a result of the second programming formula based on the identification; during execution of the software, calculating a result of the first programming formula based on a result of calculating the second programming formula; and during execution of the software, returning the calculated result of the first programming formula in association with the reference to the first programming formula.
[0003] In some aspects, the technology described herein relates to a computing system comprising: one or more hardware processors configured to execute software containing a programming formula; and a deferred formula calculation request program code associated with a reference to the programming formula in the software, wherein the deferred formula calculation request program code is executed by the one or more hardware processors based on encountering the reference during runtime in the software to obtain a result of the programming formula during runtime in the software, wherein the deferred formula calculation request program code is further configured to determine that the result of the programming formula has not been calculated during runtime in the software, to cause calculation of the result of the programming formula during runtime in the software based on the determination, and to return the calculation result of the programming formula in association with the reference to the programming formula during runtime in the software.
[0004] In some aspects, the techniques described herein relate to one or more tangible processor-readable storage media embodied with instructions for performing a process on one or more processors and circuits of a computing device, the process comprising: executing software containing a set of programming formulas, wherein the set includes a first programming formula, the first programming formula being defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a deferred formula calculation request program code in the software to obtain a result of the first programming formula; during execution of the software, identifying the second programming formula based on a traversal within an associated dependency graph of the first programming formula; during execution of the software, calculating a result of the second programming formula based on the identification; during execution of the software, calculating a result of the first programming formula based on a result of calculating the second programming formula; and during execution of the software, returning the calculated result of the first programming formula in association with the reference to the first programming formula.
[0005] 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.
[0006] Other implementations are also described and listed herein. BRIEF DESCRIPTION OF THE DRAWINGS
[0007] Figure 1 An example delay formula calculation in a software execution environment is shown.
[0008] Figure 2 Software is shown that performs example delay formula calculations in a software execution environment.
[0009] Figure 3 Example operations are shown for providing delay formula calculations in a software execution environment.
[0010] Figure 4 Alternative example operations are shown for providing delay formula calculations in a software execution environment.
[0011] Figure 5 An example computing device for use in delay formula calculations is shown. DETAILED DESCRIPTION
[0012] The described technology provides a delayed formula calculation function for programmers of software applications. Both programmers and users can benefit from the delayed formula calculation function because it can speed up software program startup (e.g., before the user has access to the user interface of the software) and reduce data retrieval and calculation resources until and unless formula calculation is called as part of the user's interaction with the software.
[0013] In computer science, procedural programs using imperative programming are modeled as a series of operations that occur in a specific order and can be sequential and subject to control flow (instructing the program to choose a specific path). Procedural programming is a type of imperative programming in which programs are constructed from one or more procedures (also known as subroutines or functions) in some specified order with appropriate control flow. Programs focus on commands consistent with the von Neumann vision of sequential programming, where data is usually "stationary". In contrast, dataflow programming emphasizes the movement of data and model programs as a series of connections. Declarative programming (a type of imperative programming) is compatible with dataflow programming in many ways. Clearly defined input and output connection operations, which function like black boxes. Once all of its inputs become valid, the operation is executed. Therefore, dataflow languages are inherently parallel and can work well in large decentralized systems.
[0014] Thus, imperative programming is a programming paradigm for software that uses statements that change the state of a program. In contrast, in declarative programming, the logic of a computation is expressed without describing its control flow. Programming formulas describe expected values based on dependencies, rather than procedurally defining how and when to calculate the resulting values. Furthermore, as used by the described techniques, the calculation of programming formulas is based on component dependencies, just as it is in a mathematical sense. Dependencies can be records in a database, data from a user interface, other programming formulas, or any other input. Furthermore, it should be understood that programming formulas are time-invariant, but the results of the programmed formulas may change over time as the results of the component formulas and / or input data change.
[0015] As an example of statements in imperative programming relative to programming formulas in declarative programming, the following statement is provided:
[0016] ● Statements where the programmer sets them in command programming (for example, in App.OnStart):
[0017] Set(X,4) / / Sets X to 4 once when this statement is executed, and thereafter X can change unexpectedly from the original 4.
[0018] ●Where the programmer defines programming formulas (e.g., in App.Formulas):
[0019] X = 4 / / defines X to be 4 for all times. There is no time for this formula to hold true, so it does not matter when the implementation executes it or if it ever executes it.
[0020] In delayed formula calculation, a programmed formula calculation is established for the execution life of a software program. Unlike setting global variables via command programming at a specific point in runtime execution (e.g., at startup or start), programmed formulas specify relationships that define how results can be calculated. Thus, the described techniques enable delayed calculation of such formulas (e.g., delaying calculation of a formula until the execution of the program requires the calculation of a result, such as when a user executes a specific function that requires a result).
[0021] In addition, a programming formula can have component formulas and values upon which it depends. Thus, when the results of the component formulas and component values (e.g., input data) change, dataflow programming can indicate that the results of the programming formulas should be recalculated. However, delaying formula calculation can further delay the recalculation until the user performs a specific function that requires the updated results.
[0022] Figure 1 An example delay formula calculation in a software execution environment 100 is shown. The software program (software 102) performs a designed function, which accesses data in a database 104 and presents three different user interface pages (user interface page 106, user interface page 108, and user interface page 110) to the user in the order indicated by the arrows labeled "User Progress", such as in a display screen. For example, the user interface page 106 may be presented to the user initially, and then, with the user's interaction with the software 102, the user interface page 108 will be presented to the user. In this example, the user does not progress to the user interface page 110, but terminates the execution of the software 102.
[0023] This example illustrates the problem solved by the described technology. When the software 102 is initially started, many calculations may be performed. In some implementations, these initial startup calculations are programmed into the beginning of the startup process because they are attributed to the Start feature. The Start feature specifies that when the user starts the software 102, the code will run. This feature is often used to perform the following tasks:
[0024] ●Retrieve data by using the collection function and cache it into a collection.
[0025] ●Set global variables by using the Set function.
[0026] Thus, the command programming attributed to the start feature is executed, and the data upon which the same programming depends is retrieved / cached before the first screen appears. Specifically, the retrieval / caching of such data can be time and resource intensive. There are no loading screens during the start execution, so the user is waiting for the user interface to become accessible. Thus, the calculation of statements or SET operations of a large number of command programming and the retrieval / caching of associated data at startup can impair the user experience, as the user waits for access to the user interface while the startup operation is completed.
[0027] This impairment is particularly frustrating because, depending on how the user uses the software, many of the command result calculations may never actually be needed during the runtime of the software 102. Figure 1 , during the execution session, the user does not even access the user interface page 110. As such, some result computation and data retrieval / caching for the user interface page 110 is a wasted activity. Therefore, the described techniques implement deferring computation by writing the logic as time-invariant programming formulas, rather than as command steps that must be executed at specific times, thereby deferring data retrieval / caching for the user interface page 110 until the runtime execution of the software 102 encounters a reference to the formula in the program code that renders the user interface page 110. Figure 1 In the process, the user does not access the user interface page 110, so the corresponding formula calculation and data retrieval / caching are not performed. Similarly, the formula calculation and data retrieval / caching for the user interface page 106 and the user interface page 108 are also delayed until each page is presented. Therefore, the user experience during the startup sequence is faster and less frustrating.
[0028] Figure 2 Software 200 is shown executing an example delay formula calculation in a software execution environment 202. Figure 2 In the software, a reference to a formula (formula reference 204) is included. In one example, a formula is used to calculate the dimensions of a form field in a page of a mobile application, which may include retrieving database records to fill the field, adjusting the size of the field to display correctly on the screen of the mobile device, etc. In addition to encoding the calculation as command logic that must be executed during the startup sequence, the programmer defines the calculation as a "named formula" that does not change over time, which causes the compiler to add a delayed formula calculation request program code 206 at compile time to delay the calculation of the named formula until it is needed. For example, the compiler can add a delayed formula calculation request program code 206 to trigger a call from a calling site (delayed formula calculation request 208 in runtime execution) to request delayed formula execution of the referenced formula.
[0029] In one implementation, the deferred formula execution request checks the formula result cache 210 to determine whether the result of the referenced formula has already been calculated (e.g., computed). Note: the formula reference 204 may have been encountered in an earlier portion of the runtime execution (e.g., for a user interface page that has been accessed by a user after startup). As such, the result may not need to be recalculated—if the result associated with the formula reference 204 is in the cache and is not stale, the result may be returned from the formula result cache 210 to the calling site.
[0030] In some implementations, a reference formula may have one or more component dependencies, including data that may need to be retrieved or updated from a database and component formulas that may need to be calculated or updated before the reference formula can be calculated. In this case, even if the result of the reference formula is stored in the formula result cache 210, it may be stale (e.g., no longer valid). Thus, the delayed formula calculation request 208 (and / or the requested program code it calls) can analyze the dependency graph 214 associated with the reference formula to identify these data and component dependencies, retrieve and / or update the required data and formula results, and complete the latest calculation of the reference formula. The result 212 of the latest delayed calculation is returned to the call site in the runtime execution flow.
[0031] In at least one implementation, the dependency graph 214 provides relationships among programming formulas and their component programming formulas and other data (if any) that constitute the elements of the programming formulas and their components. For example, if a first programming formula depends on a second programming formula, the dependency is indicated in the dependency graph. Similarly, if the first programming formula depends on a data element (e.g., a record in a database), the dependency is indicated in the dependency graph. In this way, the execution software traverses the dependency graph to recursively identify dependencies (e.g., the identities of component data and component programming formulas) so that lower dependencies (e.g., data and formulas) in the graph can be resolved (e.g., updated / calculated) before resolving parent nodes, and so on, up through the dependency graph to the first programming formula (e.g., at the top of the dependency tree).
[0032] To further illustrate the described techniques, a program code snippet with some description is provided below. In code sample 1 (below), a named formula "colNav" is defined:
[0033]
[0034] Code Sample 1
[0035] In code sample 2 (below), the named formula "colNav" is referenced twice in a script for an AppSwitcher component executed during runtime. When the AppSwitcher component is compiled, the compiler inserts deferred formula evaluation request program code associated with each named formula reference (in bold) to issue deferred formula evaluation requests 208 during runtime that evaluate the formula result cache 210 and / or the dependency graph 214 to retrieve results 212.
[0036]
[0037] Code Sample 2
[0038] In one implementation, the first reference to the named formula "colNav" (in the line beginning with "ThisAppStartScreen") can be the first reference to the named formula encountered during runtime. Thus, the program code added during compile time requests the result of the named formula, which can involve checking the formula result cache 210 and / or the dependency graph 214. If the formula result cache 210 contains the latest result for the named formula, the result 212 is returned to the calling site. If not, the result 212 is calculated or updated, stored in the formula result cache 210, and returned to the calling site. At the second reference, the same operation is triggered, so that the result calculation is evaluated again, and the result 212 may be returned only from the formula result cache 210. Thus, the program code can perform the same or similar checks to confirm that the cached result is the latest before returning the result 212.
[0039] Figure 3 An example operation 300 of providing delayed formula calculation in a software execution environment is shown. During runtime, a startup operation 302 executes software containing a programming formula. A trigger operation 304 encounters a reference to the programming formula during runtime of the execution software. The reference is associated with a delayed formula calculation request program code in the execution software to obtain the result of the programming formula. A request operation 306 executes the delayed formula calculation request program code based on encountering the reference during runtime in the execution software. In one implementation, the delayed formula calculation request program code is added to the software during compile time, although such program code may also be added to an interpreted or uncompiled code execution environment.
[0040] Decision block 308 determines whether the result of the programming formula has been calculated and is up to date during runtime in the execution software from the execution program code. In one implementation, the result that has been calculated is stored in the formula result cache, although other storage destinations can be adopted. If the result of the programming formula has been calculated (and its dependency is up to date), then in the return operation 314, the result that has been calculated is returned to the call site during runtime execution. If the result of the programming formula has not been calculated (or its dependency is up to date), the delay calculation operation 310 calculates the result of the reference formula. The delay calculation operation 310 can retrieve / update component data and / or calculate / update the component formula of the reference formula, such as by querying the dependency graph associated with the reference formula. Another return operation 312 returns the new computer / updated result to the call site during runtime execution.
[0041] Figure 4 An alternative example operation 400 for providing a delay formula calculation in a software execution environment is shown. An execution operation 402 executes software containing a set of programming formulas, wherein the set includes a first programming formula, which is defined in an associated dependency graph as being dependent on a result of a second programming formula. A reference operation 404 encounters a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a delay formula calculation request program code in the software to obtain a result of the first programming formula. An identification operation 406 identifies the second programming formula based on a traversal within an associated dependency graph of the first programming formula during execution of the software. A calculation operation 408 calculates a result of the second programming formula based on the identification operation 406 during execution of the software. Another calculation operation 410 calculates a result of the first programming formula based on the result of calculating the second programming formula during execution of the software. A result operation 412 returns a calculation result of the first programming formula in association with the reference to the first programming formula during execution of the software.
[0042] Figure 5 An example computing device for use in delay formula calculations is shown. Computing device 500 may be a client device, such as a laptop computer, a mobile device, a desktop computer, a tablet computer, or a server / cloud device. Computing device 500 includes one or more processors 502 and memory 504. Memory 504 typically includes volatile memory (e.g., RAM) and non-volatile memory (e.g., flash memory). Operating system 510 resides in memory 504 and is executed by (multiple) processors 502.
[0043] In the example computing device 500, as Figure 5As shown in , one or more modules or segments such as application 550, delayed formula calculation request program code, and other program codes and modules are loaded into the operating system 510 on the memory 504 and / or storage device 520, and executed by (multiple) processors 502. The storage device 520 can store delayed formula calculation request program code and other program codes, dependency graphs, formula result caches, database content, and other data, and is local to the computing device 500 or can be remote and communicatively connected to the computing device 500. Specifically, in one implementation, the components of delayed formula calculation can be implemented entirely in hardware or in a combination of hardware circuit devices and software.
[0044] Computing device 500 includes power supply 516, which is powered by one or more batteries or other power sources, and which provides power to other components of computing device 500. Power supply 516 may also be connected to an external power source that overwrites or recharges the internal batteries or other power sources.
[0045] The computing device 500 may include one or more communication transceivers 530, which may be connected to one or more antennas 532 to provide network connectivity (e.g., mobile phone networks, ). The computing device 500 may also include a communication interface 536 (such as a network adapter or I / O port as a type of communication device). The computing device 500 may use adapters and any other type of communication device for establishing connections on a wide area network (WAN) or a local area network (LAN). It should be understood that the network connections shown are exemplary and other communication devices and means for establishing communication links between the computing device 500 and other devices may be used.
[0046] The computing device 500 may include one or more input devices 534 so that a user can enter commands and information (e.g., a keyboard or mouse). These and other input devices may be coupled to a server by one or more interfaces 538, such as a serial port interface, a parallel port, or a universal serial bus (USB). The computing device 500 may also include a display 522, such as a touch screen display.
[0047] The computing device 500 may include various tangible processor-readable storage media and intangible processor-readable communication signals. Tangible processor-readable storage may be embodied by any available media that can be accessed by the computing device 500 and may include volatile and non-volatile storage media and removable and non-removable storage media. Tangible processor-readable storage media do not include intangible communication signals (such as the signals themselves) and include volatile and non-volatile storage media, removable and non-removable storage media implemented in any method or technology for storing information such as processor-readable instructions, data structures, program modules, or other data. Tangible processor-readable storage media include, but are not limited to: RAM, ROM, EEPROM, flash memory, or other memory technology; CDROM, digital versatile disk (DVD) or other optical disk storage; cassettes, magnetic tape, disk storage, such or other magnetic storage devices; or any other tangible media that can be used to store the desired information and can be accessed by the computing device 500. In contrast to tangible processor-readable storage media, intangible processor-readable communication signals may embody processor-readable instructions, data structures, program modules, or other data residing in a modulated data signal such as a carrier wave or other signal transmission mechanism. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, intangible communication signals include signals propagated through wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media.
[0048] Clause 1. A method, comprising: executing software including a set of programming formulas, wherein the set includes a first programming formula, the first programming formula being defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a deferred formula computation requesting program code in the software to obtain a result of the first programming formula; identifying the second programming formula during execution of the software based on a traversal within an associated dependency graph of the first programming formula; computing the result of the second programming formula during execution of the software based on the identification; computing the result of the first programming formula based on the result of computing the second programming formula during execution of the software; and returning the computation result of the first programming formula in association with the reference to the first programming formula during execution of the software.
[0049] Clause 2. A method as recited in any preceding method clause, wherein based on encountering a reference to the first programming formula during compile time, deferred formula computation request program code associated with the reference is inserted into the software at compile time.
[0050] Clause 3. The method of any preceding method clause, further comprising: executing a deferred formula calculation request program code based on encountering the reference during execution of the software, wherein execution of the deferred formula calculation request program code determines whether a result of the first programming formula has been calculated during execution of the software.
[0051] Clause 4. A method as recited in any preceding method clause, wherein the identifying operation examines an associated dependency graph indicating a component of the first programming formula, determines that the indicated component is up to date, and calculates a result of the first programming formula.
[0052] Clause 5. A method according to any preceding method clause, wherein the identifying operation examines an associated dependency graph of components indicating the first programming formula, determines that one or more of the indicated components are not up to date, updates one or more of the indicated components, and calculates a result of the first programming formula based on the indicated components and the updates.
[0053] Clause 6. The method of any preceding method clause, further comprising: executing a deferred formula evaluation request program code based on encountering the reference during execution of the software, wherein execution of the deferred formula evaluation request program code triggers a traversal within an associated dependency graph of the first programming formula.
[0054] Clause 7. The method of any preceding method clause, further comprising: executing a delayed formula calculation request program code associated with the reference to determine that a result of a second programming formula has not been calculated during execution of the software.
[0055] Clause 8. A computing system comprising: one or more hardware processors configured to execute software containing a programming formula; and deferred formula calculation request program code associated with a reference to a programming formula in the software, wherein based on encountering the reference during a runtime in the software, the deferred formula calculation request program code is executed by the one or more hardware processors to obtain a result of the programming formula during a runtime in the software, wherein the deferred formula calculation request program code is further configured to determine that a result of the programming formula has not been calculated during a runtime in the software, to cause calculation of the result of the programming formula during a runtime in the software based on the determination, and to return the calculation result of the programming formula during a runtime in the software in association with the reference to the programming formula.
[0056] Clause 9. A computing system as recited in any preceding computing system clause, wherein based on encountering a reference to a programming formula during compile time, a deferred formula computation request program code associated with the reference is inserted into the software at compile time.
[0057] Clause 10. A computing system as described in any preceding computing system clause, wherein the deferred formula calculation requests the program code to determine whether a result of the programmed formula has been calculated during runtime of the software.
[0058] Clause 11. A computing system as described in any preceding computing system clause, wherein the deferred formula calculation request program code examines a dependency graph indicating components of a programming formula, determines that the indicated components are up to date, and calculates a result of the programming formula.
[0059] Clause 12. A computing system as described in any preceding computing system clause, wherein the deferred formula calculation request program code examines a dependency graph of components indicating a programming formula, determines that one or more of the indicated components are not up to date, updates one or more of the indicated components, and calculates a result of the programming formula based on the indicated components and the updates.
[0060] Clause 13. A computing system as described in any preceding computing system clause, wherein the indicated component includes input data.
[0061] Clause 14. A computing system as described in any preceding computing system clause, wherein the indicated component includes other formulas.
[0062] Clause 15. One or more tangible processor-readable storage media embodying instructions for performing a process on one or more processors and circuits of a computing device, the process comprising: executing software containing a set of programming formulas, wherein the set includes a first programming formula that is defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a deferred formula calculation request program code in the software to obtain a result of the first programming formula; during execution of the software, identifying the second programming formula based on a traversal within the associated dependency graph of the first programming formula; during execution of the software, calculating a result of the second programming formula based on the identification; during execution of the software, calculating a result of the first programming formula based on a result of calculating the second programming formula; and during execution of the software, returning the result of the calculation of the first programming formula in association with the reference to the first programming formula.
[0063] Clause 16. The one or more tangible processor-readable storage media of any preceding medium clause, wherein based on encountering a reference to the first programming formula during compile time, a delayed formula calculation request program code associated with the reference is inserted into the software at compile time.
[0064] Clause 17. The one or more tangible processor-readable storage media of any preceding medium clause, wherein executing the delayed formula calculation requests the program code to determine whether a result of the first programmed formula has been calculated during execution of the software.
[0065] Clause 18. One or more tangible processor-readable storage media as recited in any preceding medium clause, wherein the identifying operation examines an associated dependency graph of a component indicative of a first programming formula, determines that the indicated component is up to date, and calculates a result of the first programming formula.
[0066] Clause 19. One or more tangible processor-readable storage media as described in any preceding medium clause, wherein the identification operation examines an associated dependency graph of components indicating a first programming formula, determines that one or more of the indicated components are not up to date, updates one or more of the indicated components, and calculates a result of the first programming formula based on the indicated components and the updates.
[0067] Clause 20. One or more tangible processor-readable storage media as recited in any preceding medium clause, wherein the indicated components comprise input data or other programming formulas.
[0068] Clause 21. A system comprising: means for executing software comprising a set of programming formulas, wherein the set includes a first programming formula that is defined in an associated dependency graph as being dependent on a result of a second programming formula; means for encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with executing a deferred formula computation request program code in the software to obtain a result of the first programming formula; means for identifying the second programming formula based on a traversal within the associated dependency graph of the first programming formula during execution of the software; means for computing the result of the second programming formula based on the identification during execution of the software; means for computing the result of the first programming formula based on the result of computing the second programming formula during execution of the software; and means for returning the computation result of the first programming formula in association with the reference to the first programming formula during execution of the software.
[0069] Clause 22. A system as recited in any preceding system clause, wherein based on encountering a reference to the first programming formula during compile time, a deferred formula computation request program code associated with the reference is inserted into the software at compile time.
[0070] Clause 23. A system as described in any preceding system clause, further comprising: means for executing a delayed formula calculation request program code based on encountering the reference during execution of the software, wherein execution of the delayed formula calculation request program code determines whether a result of the first programming formula has been calculated during execution of the software.
[0071] Clause 24. A system as described in any preceding system clause, wherein the means for identifying examines an associated dependency graph indicating a component of the first programming formula, determines that the indicated component is up to date, and calculates a result of the first programming formula.
[0072] Clause 25. A system as described in any preceding system clause, wherein the means for identifying examines an associated dependency graph of components indicating a first programming formula, determines that one or more of the indicated components are not up to date, updates one or more of the indicated components, and calculates a result of the first programming formula based on the indicated components and the updates.
[0073] Clause 26. The system of any preceding system clause, further comprising: means for executing a deferred formula evaluation request program code based on encountering the reference during execution of the software, wherein execution of the deferred formula evaluation request program code triggers a traversal within an associated dependency graph of the first programming formula.
[0074] Clause 27. The system of any preceding system clause, further comprising: means for executing a delayed formula calculation request program code associated with the reference to determine that a result of the second programming formula has not been calculated during execution of the software.
[0075] Some implementations may include articles of manufacture. Articles of manufacture may include tangible storage media to store logic. Examples of storage media may include one or more types of computer-readable storage media capable of storing electronic data, including volatile or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writable or rewritable memory, etc. Examples of logic may include various software elements, such as software components, programs, applications, computer programs, applications, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, operating segments, methods, processes, software interfaces, application program interfaces (APIs), instruction sets, computing codes, computer codes, code segments, computer code segments, words, values, symbols, or any combination thereof. In one implementation, for example, articles of manufacture may store executable computer program instructions that, when executed by a computer, cause the computer to perform methods and / or operations according to the described embodiments. Executable computer program instructions may include any appropriate type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, etc. Executable computer program instructions can be implemented according to a predefined computer language, manner or syntax to instruct a computer to perform a certain operation segment. These instructions can be implemented using any appropriate high-level, low-level, object-oriented, visual, compiled and / or interpreted programming language.
[0076] The implementation described herein is implemented as logical steps in one or more computer systems. Logical operations can be implemented as a sequence of (1) processor-implemented steps executed in one or more computer systems and (2) interconnected machines or circuit modules within one or more computer systems. Implementation is a matter of choice, depending on the performance requirements of the computer system utilized. Therefore, the logical operations that make up the implementation described herein are variously referred to as operations, steps, objects, or modules. In addition, it should be understood that the logical operations can be performed in any order, unless otherwise explicitly stated or in a specific order inherently required by the claim language.
Claims
1. A method comprising: executing software comprising a set of programming formulas, wherein the set includes a first programming formula, the first programming formula being defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with a delayed formula calculation requesting program code in the executed software to obtain a result of the first programming formula; during execution of the software, identifying the second programming formula based on a traversal within the associated dependency graph of the first programming formula, wherein the identifying operation includes examining the associated dependency graph indicating a component of the first programming formula, determining that the indicated component is up-to-date in a formula result cache, and calculating the result of the first programming formula; during execution of the software, calculating a result of the second programming formula based on the identification; during execution of the software, calculating the result of the first programming formula based on calculating the result of the second programming formula; as well as During execution of the software, the calculated result of the first programming formula is returned in association with the reference to the first programming formula.
2. The method of claim 1, wherein the deferred formula computation request program code associated with the reference is inserted into the software at compile time based on encountering the reference to the first programming formula during compile time.
3. The method according to claim 1, further comprising: The deferred formula calculation request program code is executed based on encountering the reference during the execution of the software, wherein execution of the deferred formula calculation request program code determines whether the result of the first programming formula has been calculated during the execution of the software.
4. The method according to claim 1, wherein the identification operation comprises: A determination is made prior to calculating the result of the first programming formula that the component indicated is up-to-date in the formula result cache.
5. The method of claim 1 , wherein the identification operation examines the associated dependency graph of components indicating the first programming formula, determines that one or more of the indicated components are not up to date, updates the one or more of the indicated components, and calculates the result of the first programming formula based on the indicated components and the updates.
6. The method according to claim 1, further comprising: The deferred formula computation requesting program code is executed based on encountering the reference during the execution of the software, wherein execution of the deferred formula computation requesting program code triggers the traversal within the associated dependency graph of the first programming formula.
7. The method according to claim 1, further comprising: The delayed formula calculation request program code associated with the reference is executed to determine that the result of the second programming formula has not been calculated during execution of the software.
8. A computing system comprising: one or more hardware processors configured to execute software containing programmed formulas; as well as a deferred formula calculation request program code associated with a reference to the programming formula in the software, wherein based on encountering the reference during runtime in the software, the deferred formula calculation request program code is executed by the one or more hardware processors to obtain a result of the programming formula during runtime in the software, wherein the deferred formula calculation request program code is further configured to determine that the result of the programming formula has not been calculated during runtime in the software, to cause calculation of the result of the programming formula during runtime in the software based on the determination, and to return the calculation result of the programming formula in association with the reference to the programming formula during runtime in the software.
9. The computing system of claim 8, wherein the deferred formula computation request program code associated with the reference is inserted into the software at compile time based on encountering the reference to the programming formula during compile time.
10. The computing system of claim 8, wherein the deferred formula calculation request program code determines whether the result of the programming formula has been calculated during runtime of the software.
11. The computing system of claim 8, wherein the deferred formula calculation requests program code to examine a dependency graph indicating components of the programming formula, determine that the indicated components are up to date, and calculate the result of the programming formula.
12. The computing system of claim 8, wherein the deferred formula calculation requests program code to examine a dependency graph of components indicating the programming formula, determine that one or more of the indicated components are not up to date, update the one or more of the indicated components, and calculate the result of the programming formula based on the indicated components and the updates.
13. The computing system of claim 12, wherein the indicated components include input data. The computing system of claim 12 , wherein the components indicated include other formulas.
15. One or more tangible processor-readable storage media embodying instructions for executing a process on one or more processors and circuits of a computing device, the process comprising: executing software comprising a set of programming formulas, wherein the set includes a first programming formula, the first programming formula being defined in an associated dependency graph as being dependent on a result of a second programming formula; encountering a reference to the first programming formula during execution of the software, wherein the reference is associated with a delayed formula calculation requesting program code in the executed software to obtain a result of the first programming formula; during execution of the software, identifying the second programming formula based on a traversal within the associated dependency graph of the first programming formula; during execution of the software, calculating the result of the second programming formula based on the identification; during execution of the software, calculating the result of the first programming formula based on calculating the result of the second programming formula; as well as During execution of the software, the calculation result of the first programming formula is returned in association with the reference to the first programming formula.