> I've been pondering about what a syntax free language might look like.
>
> Perhaps something like max/puredata. These graph based languages still
> have textual labels like other languages, but the syntax is done by
> connecting the labels together with wires, to particular inlets and
> outlets.
>
> But how could you get the meaning across without the syntax of wires? I
> think by making distance meaningful, putting labels close together or
> far apart would somehow describe their relationship. Instead of a graph
> of labels you would make clusters of labels with particular semantic
> arrangements.
The languages at either end of the programming spectrum are pretty much
syntax free - assembler and lisp. Lisp just has lists, and assembler is
just instructions in order with jumps. Of course a lot of modern assembler
is much more, but in essence it's like this.
Both have the reputation of being very difficult at first to understand,
but also they can exhibit almost zen like simplicity. Interestingly they
also both lack strong distinction between what is data and code - I think
that is important.
> I suppose you could just end up re-implementing wires - instead of
> explicitly connecting labels, you implicitly connect them, perhaps
> nearest neighbours are connected together via compatible inlets /
> outlets. This could be an efficient way of making a graph. But I'm
> thinking beyond this, to a system where programs are described using
> shape, where distance is meaningful... For example if I move one
> oscillator closer to another one they influence each other more and
> begin to harmonise, or if I move a bang closer to a counter, the counter
> resets on a bang more often.
I'm really interested in this topic, and I can't help mentioning daisy
chain. That is a 'code flow' language, rather than data flow, so
instructions move around a structure and execute concurrently when they
collide with each other - modifying the underlying structure. It 'works',
but it's really hard to map such behavior onto something else - to
actually deal with input or output.
These sort of things are on the edge of what we understand as programming
languages, so I've sort of made up some rules that I go by, that such
things need to have an axiomatic instruction set of some sort, and need to
self modify - I think that gives them enough complexity to almost qualify,
although I'm not sure what as exactly :)
cheers,
dave
Received on Thu Mar 06 2008 - 10:55:53 GMT