Sun Jan 27 22:46:49 CET 2013

Dimensions: TIME vs. SPACE

Wow what a day.. some things to take home:

- Feedback has a context == the "dimension" along which state is fed
  back.  This creates problems

- The whole game is about properly handling multi-dimensional arrays
  (data) which mirror directly in nested loop structure (code).

  This really isn't so hard when it is done explicitly, but it is a
  pain to work with indices directly.

The feedback notation basically abstracts state.  


For the kind of code I want to write (Music DSP), there are a lot of
IIR filters (think damped sinusoids) which all have:

- local state: only relevant in a very small part of the code

- a lot of state accumulating at higher levels (when using functional

Keeping it behind the scenes helps.

However... when there are more dimensions, it becomes hard to just
tuck it away.

But in practice, this might not matter.

* The only points where such bulky local state is important is for
  things that have to do with time.

* Other accumulations really are just accumulations e.g. product, sum,
  min/max, ... of *finite* structures (a collection of modules, an FFT
  block, a signal block matrix, ...) and might just as well be
  expressed explicitly.  Such state is also not retained.  With time,
  we have an "open" loop.

* A very special case would be an iterative numerical algorithm, which
  probably is also best expressed explicitly.

Really.. the only thing I'm looking at are GLUE FILTERS.

It is very useful for such things, but a pain for almost anything
else.  My needs are very specific.

So, for now:

* All system feedback syntax refers to TOP LEVEL TIME ONLY.  All code
  is stream processing code embedded emplicitly in a time iteration

* A separate fold/map operator allows spatial operations.  All
  referenced variables are automatically lifted to streams by the type
  inference algo.  ( Later, maybe add a "constant" operator: t -> S t )


* Provide the ability to create "local time" in a loop.  The only
  reason for doing this is expressing iterative numerical algorithms
  as a causal stream processor.  The question is if this is really

* Design a separate set of abstractions for "symmetric" grid
  processing, i.e. where all accumulation is associative and there is
  no iteration direction introduced by state feedback.  (time is
  a-symetric, but space isn't)

  (Then there are two languages: TIME and SPACE ;)