TODO List

Flow
* use overload operators to create chains ('=>' or maybe '|' or '+')
* a threshold parameter that controls how many items can be passed, at most,
  in a single run
* start messing with parallel runs, via fork or threads
* use some logging facility
  - make a proper error handling/alerting code
* refactor Node and Chain and the underlying logic:
  - create a Processor class (or role? gotta think more)
    - a Processor has only the processing logic
	- the Node will have the queues
	- a Processor receives (inputq,outputq) for the processing call
	  (this will allow to easily modify, dynamically, the input/output queues
	   being used - useful for Chain and for process() )
  - Node becomes a 'runner' for a Processor
  - Chain will have an array of queues, and processing items through the pipe
    becomes a matter of calling the processors with each pair of queues

Chain
* in a chain, the output from the previous node should be the same object in
  memory as the input of the next node
* the chain's input queue must be the same object as the first link's input
  queue, and conversely, the last link's output queue must be the same object
  as the chain's output queue

Nodes
* file reading/writing node
* char encoding node (there is a first attempt there already, needs to work
  on it and write tests for it)
* an OCR decoding module (any OCR perl modules out-there?)
* a node that runs an external command (system(), or IPC::Run, or...) and maps
  stdin, stdout, stderr respectively to input, output and error queues
* split and join nodes, to allow flows to follow multiple paths
* node(s) to read from and write to message queues (AMQP, MQSeries, ...)
* node that generates RDF content

Item
* start using DataFlow::Item to carry data and metadata through the flow
* autoboxing of data into an Item?
* autofill metadata?
* revamp everything so that nodes may have "types" - scalar, arrayrefs, 
  DataFLow::Item ??
  - one might declare a node to handle only specific types of input
  - if input fails to meet the expected type, one can choose to dicard that
    input or to pass it through unmodified.

Other
* create a DataFlow::Maker class that will read JSON/YAML/something config
  files and create DataFlows out of them

