Over the last year I created an object model for incremental computation of XSL traits.
After two implementations the problem more and more grew over my head and by stepping back a week or so, I realized that the problem itsself of computing dependable traits (XSL values, or more commonly properties), may be solved by a different, graph based approach.
The nodes of this graph are the values, connections between them relate to the functions. Changes are propagated in an invalidation phase.
When accessing an invalid value, an evaluation may be started at any time. The function responsible computing the value is called and may access other values. If a value is invalid, the evaluation for that value starts, and so on.
This basic model results in a Model/View implementation at property granularity. Multiple observers are possible and performance – when combined with memoization – seems to be efficient.
The graph itsself can be maintained by tracking all input values which are used in a function evaluation.
By using a static evaluation stack, this process can even be totally hidden, so that no additional (meta) information about the dependencies is required.
The application containing the XSL core I talked about goes in production in a few weeks, and recently I started the build a complete framework to prove the assumption that this model is useful for creating several kinds of applications.
Right now I am trying to solve the problem of effectively representing, sorting or filtering lists while maintaining the lazy nature of the evaluator core.
I think that dependable properties like the ones used in the Microsoft Presentation Foundation or at the core of the F3 language (soon to be released by Sun, here called attributes) will create a new platform for software development of interactive applications.
This concept may even be capable to solve the concurrency problem we face over the next few years.
yours armin