J. Paul Morrison

It's comparable to FBP, and indeed, such a comparison has been made, specifically with Linda: [0] In effect, the difference stems from whether you want to explicitly allocate ports to processing nodes, or if you want nodes that discern connections associatively. 9p/styx is also worth bringing into the discussion for an inverted understanding of the problem: where these languages suggest what the graph should look like when operating correctly, as in a batch process, what Plan9 did was to reason through how to connect up the nodes dynamically and debug multiprocessing "in detail", which is relevant when your connections fail. [0] https://www.jpaulmorrison.com/cgi-bin/wiki.pl?CoordinationLanguage

There's a good discussion in the Google group of the ideas that differentiate what we are now calling "classical" FBP (or CFBP) from FBP-like systems, more and more of which are appearing all the time - in particular the topic "Underlying models" - https://groups.google.com/forum/#!topic/flow-based-programming/L_E7dEU… . If you are interested in the more large volume, data-processing, "classical" FBP implementations, a good place to start is my book, "Flow-Based Programming", 2nd ed., and the web site http://www.jpaulmorrison.com/fbp/ .

This looks great, and I encourage you to keep working on it and make this a reality. I've thought along the same lines and I think a language like this has real potential. I'm pretty surprised I haven't seen J. Paul Morrison's "Flow-Based Programming" mentioned anywhere in the post or these comments. I first read this book years ago as a undergrad and it made a big impact on me. It discusses ideas very similar to the ones proposed for Glow. You can read it free online here: http://www.jpaulmorrison.com/fbp/ You can find links to several existing implementations of flow-based programming on Wikipedia: http://en.wikipedia.org/wiki/Flow-based_programming

Well, my program was a native desktop program, so the choice between JS and C++ didn't have much impact - for a lot of people this would not be an option though. I do love the idea of making your app work on various tablets - seems like the kind of interface that would be very nicely suited to a touch-centric device. It was a homemade system I made for a spreadsheet-like application. I never released it though, I should polish it a little and release it sometime when I have some spare time. The interface was very much inspired by SynthMaker[1], a little by LabView and Max/MSP, and of course JP Morrison's work[2]. [1] http://synthmaker.co.uk/ [2] http://www.jpaulmorrison.com/fbp/index.shtml

Graphical programming would be a 'killer app' for any language that can implement it first. Reasoning about code visually will not only make programming more accessible, but it will allow us to apply spatial reasoning skills to the task of writing applications. Flow-based programming seems to have the best chance of getting this sort of thing off the ground: http://www.jpaulmorrison.com/fbp/

I’m again reminded of “Flow-Based Programming”: http://www.jpaulmorrison.com/fbp/fbp2.htm

It surprised me just how huge the impact was of reading about Flow-based Programming years ago (J Paul Morrison's book, though, his site is probably a sufficient substitute http://www.jpaulmorrison.com/fbp/) Of course, in recent times, it has become all that much more relevant to me as I began working in data science/engineering space. Even though it's not specifically about code structure for a particular language, it addresses a common flaw in most programming approaches that seem to treat all functionality as a servant of the current context which is strange and silly and not how anything works in physical information processing so why do it in code? A somewhat common pattern that maps well to FBP is "Railway Oriented Programming." Though FBP in full takes this well beyond simply shooting errors along in sideband to the happy path.

Morrison has been doing and pushing the software for a while: http://www.jpaulmorrison.com/fbp/ The hardware has been done repeatedly for special-purpose applications. Maxelor has a general-purpose one used as an accelerator. https://www.maxeler.com/technology/dataflow-computing/ Not sure about pure dataflow by itself for general-purpose systems. Closest thing I've seen are VLIW-like modifications of regular processors. Not doing so well, though. "All the dependency information available to a compiler/runtime is lost when code-generating to x86 (same for ARM), yet a processor core needs to extract the same information again in hardware." You could embed it into the code or make it implicit in the ISA.

Link to inventors site about FBP: http://jpaulmorrison.com/fbp ... and of course: https://en.wikipedia.org/wiki/Flow-based_programming

You might want to look at rx reactive for dotnet/mono. I have been using rx in combination with f# for a while and really like it so far. http://msdn.microsoft.com/en-us/data/gg577609.aspx I do not understand why MSFT pronounces the linq/monad aspect of rx so much and dont advertise it's push based dataflow aspect. People would have a much easier time getting additional information and perspectives. Good information on FBP can be found here: http://www.jpaulmorrison.com/fbp/ It's also interesting to see the relationship between process calculi based dataflow and actor model based agent implementations: http://en.wikipedia.org/wiki/Actor_model_and_process_calculi I do hope that new developments in pull based FRP and push based implementations like rx lead to some elegant push/pull combination sometime.

Hi! Author of NoFlo here. This has been sort of a longtime hobby project for me, since I read J. Paul Morrison's FBP book: http://www.jpaulmorrison.com/fbp/#book The UI side of things is still in very early stages, but the engine itself is quite solid. We've been using it for various Extract-Transform-Load tasks, like report generation, as explained in http://bergie.iki.fi/blog/business_analytics_with_couchdb_and_noflo/ At Nemein we also have been using it for routing messages between different message queues. This is useful when you want to apply some business rules on them. For example, in one of the web apps I've been writing, the ORM sends a message on each I/O operation to a queue. NoFlo listens to the queue and routes the messages to correct "business logic queue". This way the ORM can focus on being an ORM, and our workflows can be kept elsewhere.

I'm just reading the book Flow-Based Programming (2nd Edition) by Paul Morrison[1]. I would say the main idea is to shift focus from control-flow to how data ("information packets") flow through a network of (black box) components and only use traditional control-flow style programming for the most simple, atomic components. The book presents some convincing examples from business programming but I think the idea should work very well for other areas than text processing, certainly for image manipulation or sound processing. The split between component creators and component assemblers (application programmers) is highlighted in the book, I hate it how often I tend to slip from one role to the other in regular programming, maybe such an explicit split would help a lot (well, or certainly a lot of experience will ...) [1] http://www.jpaulmorrison.com/fbp/

I should expand upon my comment. Anyone who claims that, "I will argue further that moving to a signal-based, synchronous software model will not only result in an improvement of several orders of magnitude in productivity, but also in programs that are guaranteed free of defects, regardless of their complexity" is not to be taken seriously. Anyone who is really interested in this model of computation would be far better off reading this: http://jpaulmorrison.com/fbp/ At least J. Paul Morrison doesn't claim that his approach is infallible. Indeed he goes to some length to point out the troublesome areas and techniques to address them. The author of the OP, Louis Savain, has some other strange ideas also: http://scienceblogs.com/strangerfruit/2008/01/laugh_along_with_louis_s…