Hello, BulatZiganshin, you wrote: BZ> it is the closest to out-of-order execution in cpu Well, it is a little quite another thing. Unless it is similar. BZ> and on me on the contrary - if in lazy the order of calculations is dictated by the data (calculating a*b, we recursively plunge into calculation and and b) in such language calculating x, we suddenly start to calculate hundreds the variables depending on it, and also in the ascending order. Really it to someone will be more clear?? Of the majority of people think imperatively. On this for them the lazy approach looks unnaturally. But actually about which I tell the approach differs from lazy not too strongly. Simply lazy calculates at first that that demand, and this all. If to present calculations as the sorted dependence graph where on the one hand nodes with constants (the input data), and on an output calculated values on finite "branches" lazy calculation will be reverse bypass of the graph, from demanded values to constant, while vigorous, on the contrary from constant and "downwards" under the column to most "sheet". As a matter of fact they can be thrust in one language. In code cases the fast response is necessary - it is possible to apply calculation. When the fast decision of mass of calculations - vigorous is necessary. BZ> the same with ghost effects - no technical issues with them in are present, they are forbidden for the ideological reasons, that a floor-mat. Concept of calculation and . The concept of performance the Problem that if value "not request" calculation will not be produced, and so, will not be also ghost effect. In remaining, it agree. BZ> at last, implementation (which I could invent) demands for each variable to create the dynamic list of variables depending on it directly, plus dynamic appropriated lambda for calculation and a sign "is already calculated". Not similar that it is more effective than laziness Well, we made implementation for the needs which allows to shorthand, by means of such language, value on a tree (AST). Value is counted or not stored in a bit field of each node of nuclear heating plant and makes on bit on dependent property (there we name such values). Not efficiency consists that our algorithm of calculation "cuts circles" on AST, and under unfavorable circumstances, these circles it can appear more than it is necessary for the linear calculation. We cannot create a dependence graph statically or dynamic, as ours AST dynamic changed. But we produce local sorting (for one node) and we rely that in practice the tree in 99 % of cases manages on the right-on the left, on top-downwards (for exceptions of cases when it intentionally forms separate passes). Good productivity As a result turns out. But at all of us not high-grade language, and DSL restricted to data handling on a tree (AST). I do not know what mechanisms are used in same Haskele for effective calculation of lazy model. If links, I will be grateful. BZ> as a whole, in comparison with laziness quits less conveniently for debugging, For debugging, just very conveniently. It is possible to trace. It is possible to put break points in each assignment and to look values. And, it is possible to fulfill on steps passing to following calculated value. BZ> demands more calculations (we calculate all that is possible, instead of all that is necessary), Here it is the big question. It is assured that lazy calculations are not given free of charge. It would be desirable to estimate these expenses and to compare to those that we have. In an ideal, it is possible even to try to make hybrid system. It would not prevent us. In mode IDE laziness would be claimed at the initial stages of loading for acceleration and coercions GUI in operating conditions. Well, and then it is already possible to start up all calculations on separate flows for acceleration of calculations and response IDE. BZ> the order of calculations as (it is necessary to distinguish determinancy of model and specific implementation), and implementation it will be similar less effective Yes, there is a such. But the specific algorithm of calculation yields repeated result. In other, at attempt we besides receive . But we plan to make system with controllable ghost effects. Ghost effects in it can be applied only to initialization separate (for example, tables of names) and at certain stages. We entered explicit stages into language. At a stage on which the variable in it is initialized it is possible to type only given (names for the table of names). This operation commutative and associative (in mathematical sense) so it can be fulfilled in any order. At the following stage the object switches in a usage mode and it is possible to derive the data (for example to produce binding under the table of names) from it. And the idea of dependent properties allows us to initialize object in the pseudo-arbitrary order and thus not to have problems normal for the imperative approach. BZ> but it is original, on what I congratulate Thanks. Here only it is not believed that to us this idea came the first to a head. It is interesting to look at other similar. Plus it is interesting to compare it to lazy execution and whether to look it is impossible to connect these both mechanisms to get in one language of advantage of both approaches. That laziness was even not on demand that who writes the program, and necessarily its customer. We load the project in IDE - we pass in a lazy mode as fast as possible to display given to that function that at the programmer on the screen, etc. And, then we launch on a flow for each processor and we give them in a batch mode AST all the project.