It would be nice if FBP or JSON graphs had an automatic visualization powered by the-graph custom element.

Could replace backtick-delimited code blocks with a button to switch between code and graph view.

noflo/visualize could be a good place to start. There is already KLay autolayout implemented there.

When I click on https://github.com/flowbased/flowbased.org/blob/gh-pages/index.html , I just see raw html - anyone know why this? I am running it on Firefox, Win 7.

TIA

Paul M.

Can't visualize this! Do you have a concrete example?!

TIA

A description is needed for this concept.

Terminology page needs a revamp:

• Synonyms list should be put at the end of term definition to make it easier to read.
• We should probably add synonyms to the list of terms and link them to primary definitions. Not sure about this.

Also, here are terms that need to be added:

• Arc
• Edge
• Node

Please add more of the missing terms in the comments.

I created a new page talking about common flow control patterns/components, which are a core part of FBP.
Components like Delay, Escrow, Cache, etc.

Just like traditional programming environments have stack traces and core dumps, it would be useful to come up with a file format to store the state of a FBP network.

The relevant information in the file would be:

• Metadata dictionary about the environment (runtime type, versions, possible env vars, etc)
• The current graph(s) being run in the network (in the standard JSON format)
• The packets that have recently been transmitted (in the packet payload format of FBP protocol)

These files could be generated on demand from tools like Flowhub, or automatically by FBP runtimes themselves whenever an error occurs.

Various Flow-Based Programming tools could be made capable of opening these files to show the graph and the packets.

flowbased.org is no longer available?

In https://github.com/flowbased/flowbased.org/wiki/FBP-DSL , it says: "The javascript implementation of the parser assumes order of declaration as the index automatically, but this is not a characteristic of the DSL."

I assume this means that, if the parser knows that the port is an array port, and if the the port is somehow marked as an array, that the indices will be assigned automatically, unless explicitly overridden. How is the port marked as an array? I am guessing that you use empty square brackets, but, whatever you use, it should be spelled out explicitly.

Thanks in advance,

Other features like obtaining the buffer load or which indexes have incoming packets in the case of array ports are desirable for simplifying the design and implementation of some components.

This is more of a comment than a question, so I will use the enhancement tag!

a) We have never needed the cited functions (but maybe NoFlo does)

b) The load balancer I built has one "secret" function to check the number of IPs in its downstream connection

c) Input Ports should mention suspension, to parallel the way that Output Ports does...

In Definition, I changed the first sentence of the 2nd para to read

Flow-based programming considers an application as a set of processes ("black boxes") communicating via connections, which the processes access by means of "ports".

Assuming there are no objections to this, I would like to add a "Connections" heading to Concepts, before Ports, and then use the same phrasing in Connections.

The only problem is I'm not sure how we should describe connections to embrace both FBP and NoFlo. So I'll tag this as a question. Could someone take a stab at this?!

BTW In FBP, connections correspond 1:1 to (non-IIP) input ports or input array port elements. Say this somewhere?

When visiting flowbased.org, I see this ad site:

Currently in the Characteristics section it says:

Activation: From the graph designer point of view all processes are running all the time, and the library should handle activations accordingly to maintain this illusion.

This is generally true, and much of the job of the software is to "maintain this illusion", but I guess I wouldn't stress "all the time" quite so much! There may be pragmatic reasons why you don't want one or more processes to start immediately at application start. Here are a couple:

• a common trick in batch "classical" FBP is to write a stream of IPs to a file, and then read it back. This acts as a very large buffer, and is often used to resolved certain types of deadlock. For historical reasons, it is often referred to as an "infinite queue". Clearly the Reader should not start until the Writer has closed the file. While you can have the Reader start earlier, the file it is working on must not be opened too early!
• although there would be no overhead to waiting for work if all processes had their own processors, in practice you probably don't want to start paying overhead until you actually need a function. In some applications, we found that 2/3 of the processes in a given network had to do with error handling, so might never actually get sent any data to work on!

Could we say something like:

Activation: From the graph designer point of view processes are running concurrently, and it is the function of the scheduling software to allocate CPU time and manage other services as required to maintain this illusion.

Explanation required.

A Process can send and recieve from any of the ports but should restrict itself to only a read or write operation at the same time.

Huh? Are you saying that a process is single-threaded, and can only wait on one event at a time, e.g. receive, send, wait on event, wait for time, etc. (as we have said elsewhere, I think...)? Or are you trying to include some NoFlo ideas as well? TIA

An explanation of those concepts is needed for the wiki in https://github.com/flowbased/flowbased.org/wiki/Advanced-Features

Although the name on the link says "Universal", right now "classical" FBP does not talk to it. Should we discuss how it could be interfaced to "classical" FBP implementations?

@oleksandr and I also started to talk about possible extensions to DrawFBP - does that fit in here?

TIA

Don't see connection between the looper/non-looper concept and the resident/non-resident dichotomy! Perhaps someone could explain..?

This would make it possible to specify names for the ports, as opposed to a numerical index. Otherwise, it would work the same as array ports.

noflo/noflo#262

(Minor issue) "dumb data" - IPs are not totally dumb, as they can have methods in them (at least in the OO language implementations), as e.g. to create "virtual" fields, computed on the fly from other field values. Could we say that IPs are "passive" objects, whereas processes are "active" - would this help or confuse further?

While writing the previous issue, I noticed that the definition talks about "components" as nodes, etc. Actually, in my book I distinguish between "components" - the code itself - and "processes" - instances of components in the network. we need to stress that you can have multiple instances of a component in the same network.

That said, I realize that "process" is an ambiguous term in programming. In my book, 2nd ed., page ix. (Preface to 2nd ed.), I found a whole bunch of terms used in the literature for "unit of concurrency" - all no doubt with their own connotations:

process (Erlang)
actor (actor theory)
agent
transaction
thread
operator (MIT, Expressor, et al.)
vat (E language)
island (Tweak)
task (Ada)
resource (Minuet)
stage (John Hartmann’s CMS Pipelines)

I don't know what the derivation of "vat" is - something you brew beer in?

Any preferences?!

A description for this concept is required.

How do I specify the array port index in FBP DSL? https://github.com/flowbased/flowbased.org/wiki/FBP-DSL

@oleksandr, you've mentioned it several times on the mailing list that you've got clear perception of FBP's place among other dataflow systems after reading Matt Carkci's "Dataflow and Reactive Programming Systems" book. Could you probably give it a try and write the Definition page of this wiki when you have time, please?

A description is needed for this concept.

Each component may spawn one or several processes

In FBP, a component is viewed as passive - it can't do anything! So assuming that you mean that each node is a single process, which executes component code, it is not really recommended that one process spawn other processes - unless this is hidden from the network. The discussion of self-modifying networks is a separate issue, and has not really been implemented extensively in FBP.

Discussion started by @jpaulm:

I have never been able to support 0-capacity connections in any of my FBP implementations. No problem with capacities of 1 and up, but 0 eludes me! Maybe it's just me, but the DFDM team made a strong effort, and couldn't get it to work! So theoretically, OK... but pragmatically, in my experience, difficult to impossible! So, my question: do we leave 0, leave it with qualification, change it to 1, or...?

Just wondering what the status of the wiki is...

Is anyone actively maintaining it?

What is its scope - i.e. is it intended to embrace both "classical" FBP and NoFlo - any other FBP-like approaches, e.g. Kamaelia, NiFi, Erlang, IoPipe, etc., etc. ? See http://www.jpaulmorrison.com/fbp/links_external.html