FLY

FLY is a programming language based on network flows. Any non-trivial program
is a set of flows. But rather than a flowing liquid or energy, they are flows
of information. If the program can be made to be concurrent, then it is a
series of multiple flows which can be assigned to different processors and
executed simultaneously. Since FLY could handle [distributed system]
processing or multi-core processing on the same machine, it might be the
next iteration of [Prime].

A network is a set of SOURCES offering inputs (a keyboard buffer or file on
disk), one or more nodes of processing (the "network"), and a set of SINKS
where results are dumped (a screen for example or a speaker). In a traditional
programming language, a function is the "node" doing processing, the parameter
list its "sources", and the return value is its "sink".

A NETWORK is a graph of nodes and edges connected in some non-arbitrary way in
order to manage information flows and the results of computation. A SOURCE is
a static data structure composed of one or more machine language types (byte,
double, float, etc.) which could represent a key typed or a pixel on the
screen. A SINK is the same and can always be made to become an input (SOURCE)
into another processing network. A screen buffer for example can act as both
SOURCE and SINK, pushing pixel values at a given location (perhaps drawn from
a different flow) into a processing network.

An open edge (connected to only one node rather than two) is either a SOURCE
or a SINK. If a series inside a "" or a () is not the same type as the others,
a "non-homogeneous list" error is thrown and processing stopped.

FLY allows queuing of multiple inputs of the same type using a comma-separated
list inside () symbols or a non-comma separated list inside "" symbols.
Similarly, outputs can be given these forms and pushed out. Meta-objects can
use multiple inputs of different types. This is encoded architectural wisdom
from the Tao into your computer language (see also the project
JusticeLeague/wiki/Jedi).

If all inputs of a processing node are subject to the same operation, then
multiple inputs can be combined, such that a series of integers inside a ()
can be summed as if part of a multiple-input source on a node.

A sample network could consist of a "+" node, offering addition, taking any
number of inputs (SOURCES), summing them, and outputting the result (SINK).