The document discusses flow-based programming (FBP), its history and concepts. FBP defines applications as networks of processes that exchange data through message passing over predefined connections. This allows the processes to be reconnected without changing their code. The document provides examples of FBP networks and components implemented in various languages like Go, Java and JavaScript. It also discusses the benefits of FBP and its growing popularity with implementations like NoFlo.

1. Go(lang), Flow based programming, and some:
Flow-based programming
experiments in Go(lang)
AddisDev Meetup #2, Addis Ababa
Nov 11, 2014
(meetup.com/addisdev)
Samuel Lampa
@smllmp // +samuellampa // saml.rilspace.org // bionics.it
Developer at
www.farmbio.uu.se // bils.se // rilpartner.com

2. The Go programming language
#golang

3. Turned 5 yesterday (Nov 10)! :)
http://blog.golang.org/5years

4. Interest increasing every month

5. Invented at Google by Robert Griesemer, Rob
Pike and Ken Thompson

6. Go(lang) characteristics
● Open source
● Compiled (like C, C++, Pascal, etc)
● Garbage collected (Like Java)
● Statically typed (Like C++, Java, C# etc)
● Statically linked
(includes dependent code in the executable when compiling, not just linking to it when running)
● Has primitives for writing concurrent code built into the language (channels and go-routines)
● Multiplexes go-routines on operating system threads
(rather than start one thread per go-routine).
● Has a C-like syntax
● Has a small set of keywords
● Has explicit error handling (no Exception handling)
● Supports Reflection
● Has no Generic programming
● Has, for its age, a rather extensive standard library (Less need to reinvent the wheel)
● Is supported by Google, Canonical and a few other companies.

7. Go(lang) benefits
● Easy Concurrency
… due to in-built primitives, multi-plexing, and in-built garbage collector.
● Good at handling many concurrent connections
… due to concurrency primitives and the multiplexing.
● Generally good performance, especially compared to scripting languages
… due to static typing, being compiled and good concurrency primitives.
● Easy to learn
… due to small language, and similarity with existing C-like languages.
● Very easy to deploy to production (servers)
… due to static linking (Just copy the executable to the destination server!)
● Predictable code
… due to the explicit error handling (see also downside for same reason)
● Getting a lot of media attention
… and with that, a fast growing community) due to big backers like Google.

8. Go(lang) potential drawbacks
● The lack of Generic programming means that some
redundancy might be needed at times, when implementing
the same algorithm for slightly varying data types.
● Somewhat verbose code might be needed at times due to
the explicit error handling (see also upside for same reason)
● Performance can be affected (to the worse) by the pauses
incurred by the garbage collector (but being worked on!)
● Might not produce as optimized code as some other
languages, due mostly to the young age of the language
(although that improves with each release!)

9. Concurrency is not parallelism

10. Parallellism

11. Concurrency

12. Concurrency + Parallelism

13. “Pipeline” concurrency

14. Based on idea of
“Communicating Sequential Processes”
(CSP)
Especially suited for concurrent apps
that utilize multiple CPU cores

15. http://tou r.golang.org

16. Go-routines

17. Channels

18. Some Go(lang) links
● golang.org
● tour.golang.org
● groups.google.com/forum/#!forum/golang-nuts
● gplus.to/golang
● talks.golang.org/2012/concurrency.slide#1

19. Generator Function in Go

20. More advanced generator function

21. Connecting Generators together...

22. Using it ...

23. Flow-based programming
http://en.wikipedia.org/wiki/Flow-based_programming

24. What is this?

25. What is this?
Right answer: Function calls, or a
“call graph”

26. What if we could take control of this...
…and define the graph declaratively? Wow! :)
qq

27. Invented at the 60's at IBM
q
FBP Inventor J. Paul Morrison

28. The flow based programming book
- A must read
→ tinyurl.com/fbpbook

29. “In computer programming, flow­based
programming (FBP) is a programming
paradigm that defines applications as
networks of "black box" processes, which
exchange data across predefined
connections by message passing, where the
connections are specified externally to the
processes. These black box processes can be
reconnected endlessly to form different
applications without having to be changed
internally. FBP is thus naturally
component­oriented”
Wikipedia

32. Core FBP Concepts
● “Black box” processes (comp. to functions)
● Named in / outports as interfaces to processes
● Channels with bounded buffers
● Separate network definition

33. Some FBP network examples...

34. Some FBP network examples...

35. An array of benefits ...
● Change of connection wiring
without rewriting
components
● Inherently concurrent -
suited for the multi-core
CPU world!
● Testing, monitoring and
logging very easy:
Just plug in a mock-, logging-or
debugging component.
● Etc.
qq

36. Many similar tools: Unix pipes

37. Many similar tools: LabView

38. Many similar tools: Yahoo Pipes

39. Many similar tools: Apple Quartz Composer

40. Mitov Software (Video effects)

41. Implementations in many languages
● Java (JavaFBP) - github.com/jpaulm/javafbp
● C# (C#FBP) - github.com/jpaulm/csharpfbp
● C++
– CppFBP - github.com/jpaulm/cppfbp
– Dspatch - www.flowbasedprogramming.com/DSPatch/
– Blockie.io – blockie.io
● Javascript
– NoFlo - noflojs.org
– Node Red – nodered.org
● Go (GoFlow) - github.com/trustmaster/goflow
● Python (PaPy) - papy.org
● Common lisp -
● Shell script (net2sh) - sam.nipl.net/code/net2sh/net2sh
● D (Dendrite) - bitbucket.org/eris0xaa/dendrite
● …?

42. Resurgence in FBP interest with NoFlo

44. NoFlo creator Henri Bergius

45. NoFlo summary
● Based on Node.js
● Written in coffeescript
● 237 reusable components
● Successful (116% of 100k USD) Kickstarter for
in-browser UI
● FBP definition format in JSON
● Proof-of concept:
Re-implementation of Jekyll Static site generator:
16 000 LOC → 107 components
(4 custom ones of ~500 LOC, rest re-usable!)

46. The UI for NoFlo: FlowHub

47. Book on Data Flow, FBP and Reactive Programming

48. Node-RED, by IBM Emerging tech

49. Blockie.io (Swedish project)

50. My adventures in GoFlow

51. My adventures in GoFlow: Network

52. My adventures in GoFlow: Component

53. My adventures in GoFlow:
Aspiring bioinformatics library :)

54. Framework-less Flow-based programming in Go!

56. A few example components...

57. A few example components...

58. A few example components...

59. A few example components...

60. Some links
● Main website:
www.jpaulmorrison.com/fbp
● Mailing list:
tinyurl.com/fbplist
● Google+:
gplus.to/flowbased

61. Thank you!

62. Bonus slides

63. What's trending
● Stream based processing
● “New” (old) paradigms for multi-core programming
– Flow-based programming
– Actor-based programming
● Erlang / Elixir
● Akka
● Distributed programming (apps running across many computers)
– Erlang / Elixir
– GoCircuit
● Reactive programming
● New compiled languages
– Go (Google...)
– Rust (Mozilla)
– D ...

64. Some recommended news sources
● InfoQ – infoq.com
● StrangeLoop talks at InfoQ – infoq.com/strange_loop
● Prismatic – getprismatic.com
– Follow topics:
● Programming
● Distributed programming, etc...
● StatusCode Newsletter - statuscode.org
● Hacker News – news.ycombinator.com
● Hacker Newsletter – hackernewsletter.com
● My twitter - twitter.com/smllmp ;)