It worked again, I created an engine which can be used to make all kinds of value computations persistent, meaning that when input value used parameterized a complex system are changed, this engine is capable to solve all computations required to incrementally rebuild the final output by lazy evaluation.
Ok, you tell me thats nothing spectacular, one writes down the dependencies and the computation required to create the output values, then feed this information into a small interpreter and run it.
But now I tell you, that all computational dependencies are directly derived from your code and so are tracked automatically and even the graph is rebuilt if the dependency structure is changed and that automatic intermediate caches and type safety are self-evident. And more importantly, you don’t have to write one additional line of code or even think about it while creating your algorithms!
Believe me, it feels like magic. I have revamped a realtime, animatable XSL constraints based layouter which I am creating for a successor of the DVD. Now, with the new engine I don’t have to take care of when and which computations need to be done, just providing new input values and asking for the current layout simply works. It effectively resembles the methods used in pure lazy functional languages like Haskell, but is more efficient because of the caches it is even able to reuse previously computed intermediate results.
I think this engine can be applied to a whole group of computational problems. A slightly changed syntax to use derived computed values is the only price to pay. This type of dependency derivation and solver engine can be a solution to every time persistent constraint based complex animating model.
Think, don’t cook with water, and have a nice weekend!