language agnostic - handling amorphous subsystems in formal software design -

People like Alexander Stepanov and Sean Parent vote for a formal and intangible approach on software design.
The idea is to break complicated systems under the guided escal graph and hide the cyclical behavior in the nodes that represent the behavior.
The parents gave the promoters and performances on Google (by promotion, introduces the p.24 approach, even a Google talk there.)

As long as I approach I like it and think that this is an essential development, I imagine how to handle subsystem with amorphous behavior.
For example, imagine a similar pattern for state machines:

How to solve this?
Note that I'm just looking for an abstract approach.

Em>

I can think of hiding the behavior behind a node and defining various sub-DAGs for the states, but the comp design is licensed as a design If you want to influence the behavior of the main DAG from the sub-DAG.

Your question is not clear. Define the Amorphous Subsystem .

You are searching for " an abstract approach " but then you want details about the implementation in a traditional programming language ("For state machines normal Format ") So, what are you demanding?

Some additional details will help in conversation.

For an real intangible approach, look at something like this: / P>

... X-machine model structurally finite State Machine , except that the markers used to label the machine's transition to X → X

Stream X-machine is different from the model of Eilenberg, in which the original data type

x = out * * mm × * In,

Where there is an input sequence, out * is an output sequence, and memory (rest) is memory.

The advantage of this model is that while viewing the output in each stage, it allows a system to operate, one step at a time, through its states and changes. These witnesses are worth, it guarantees that special work was executed on each task. As a result, complex software systems can be broken into a hierarchy of stream X-machines , which have been designed in the bottom-bottom and tested from below. This design and test-for-dividend-and-win approach is supported by proof of the correct integration of the Florentine IPPET, which proves that test of layered machines is equivalent to testing the systematic system independently. ...

But I do not know how the presentation relates to this. He talks about a fairly mainstream approach to programming, nothing like X-machines. Anyway, the presentation is quite confusing and I no longer have time to watch the video.

The first impression of this, only reading the slide

the writer touches on many areas coincidentally / problems / solutions, apparently without recognizing it: from (for example) , (For example), for various programming techniques.

How different parts are connected and what exactly is he advocating

For practical implementation, look for general Lisp, / for C ++.

What advantages give us "new" in relation to famous approaches (for example, tools based on pre / post situations and inventions, better, horre or heiner or some programming language, such as a Sophisticated type-system, or so on)? I think the introduction of "concepts" - which, as as , are specific to C ++ - is not much simpler than using the option, is it about terminology and "politics" Is in (Finally formal methods ... but disguised).

Why programmed modules as a program and not as a tree, David Parnas advocated many decades ago? (One directly accessible from a lecture. PDF and slide). Work on X-machines is probably the answer to this question (going forward beyond the dag), but again, the authors are talking about a fairly traditional program development system in which Parson's approach is the only sensible one.

If / when I look at the video, I will update this reply.