Flow-based programming , or FBP, is a type of dataflow programming in which program steps communicate with each other by transmitting data through some kind of channel. The channels are managed by the larger system, leaving the connected components free to focus on processing input and producing output.
Whereas in dataflow programming the next step fires only after all the outputs from the previous step are prepared, in flow-based programming the next step is executed whenever data is available on any input channel. This is known as asynchronous dataflow and is in keeping with the articulated view of inputs as channels that transport messages. Essentially, the semantics of a dataflow program are those of a group of subroutines running currently, with each performing blocking reads on its inputs, processing data when it is available, and producing some output. The blocking reads are the primary means of controlling the flow of execution. Tcl, with its virtual channel features, is a natural platform for flow-based programming. Coroutines are another natural fit. The arguments passed to instantiate the coroutine are analagous to initial information packets (IIP) in flow-based programming.
Jpaulm: Bwise and LabView are both mentioned on the FBPWiki page, Flow-like Projects - including quite a long discussion about LabVIEW with Jim Kring.
Roy Terry recommends this as not only illuminating in its own right, but "amenable to Tcl implementation".
Arjen Markus: I was inspired by Software Architecture: Perspectives on an Emerging Discipline , Mary Shaw, David Garlan, to start thinking about implementing "pipelines" in Tcl. Consider the following example: we want to remove all comment lines from a C source file. One way to do this, is to read in the file, filter out those lines and pieces of text that belong to a comment and write out the remainder.
In one line:
output [nocomments [readfile $input_name]] $output_name
Or:
set content [readfile $input_name] set filtered_content [nocomments $content] output $filtered_content $output_name
So, you get a more or less complicated chain of commands, the one taking the output from the previous one.
The drawbacks of this approach are:
What, on the other hand, if we do it like this:
set infile [open $input_name r]
set outfile [open $output_name w]
while {[readline $infile line] >= 0} {
set filtered_line [nocomments $line]
outputline $filtered_line $outfile
}
close $infile
close $outfileWell, this solves the first objection to the previous method, but the second is changed into:
Two new disadvantages are added, which may even be more serious:
The book on flow-based programming by J. Paul Morrison describes a method of thinking about programs and designing them that deals with precisely the above difficulties. The solution is to have the input items (lines in this case) generate events that are then treated in order of generation by other tasks.
How can we achieve this in Tcl? Let us keep it simple - we want to show the principle, so the filtering is: convert everything to upper case.
(To be continued ...)
RS still wonders how this differs from Streams à la SICP...
Lars H: Or how this relates to bwise.
TV (Long ago maker of Bwise, inspired by Khoros and Avs and schematic diagrams (I'm Uni EE)) Thank you! The answer is: take Hoare and Milner, check out the long-existing original (? for me anyhow) AT&T and Berkeley versions of Unix from the 70s (depending on what you want, some things from the 80s) and you suddenly know most fundamentals of practical and theoretical flow based programming. Of course your concept terminology milage may vary, flow isn't usually meant the same as stream, parallelism isn't the same as multiprocessing, etc...