On Oct 5, 2009, at 1:56 PM, Chris McCormick wrote:
> On Mon, Oct 05, 2009 at 12:33:19PM +0100, alex wrote:
>> 2009/10/5 Dave Griffiths <dave_at_pawfal.org>:
>>> The difference between text and graphical programming seems fairly
>>> arbitrary to me
>>
>> Pd and max are not graphical programming languages. They are
>> textual.
>> They are no more visual than C. You make an object and it does
>> nothing until you give it a name. Then you connect it to other
>> objects also with names. You move the boxes around the screen and
>> the
>> meaning doesn't change (except with weird edge cases in Max, but
>> that's a side issue).
>
> The meaning doesn't change with the position of hte boxes, but it
> does change
> with the connections between the boxes. You can't express those
> connections
> without the graphics in Pd and Max, whilst you can in other
> languages. This is
> what makes them "graph"ical languages I beleive. I guess the
> connections replace
> named temporary variables in other languages.
>
> Hmmm, technically this is incorrect - you can actually patch with
> sends and
> receives, but nobdy does. Also you can dynamically patch
> connections but it's a
> real pain.
>
Eh, not true! There was a big movement a few years ago to use sends
and receives to create "namespaces" in MaxMSP. And I also have to
disagree about the position of boxes on the screen - it's a
fundamental part of MaxMSP that things happen from left-to-right
(this is not the case in Pd) and so you *must* read patches from left-
to-right otherwise you will get drastically different results, as
anyone who has done any real patching in Max knows.
> You can also write Pd patches in a text file, but nobody does
> (sometimes people
> do Dave's replace trick though).
>
Interesting point, but now MaxMSP patches are in JSON notation, so
they are essentially Javascript that can be livecoded and edited.
I have to disagree with Alex et. al. that visual vs. textual
programs are the same thing. They certainly aren't - textual symbols
are processed by different parts of the brain. It's a very different
experience connecting lines and occasionally typing in object names
than typing everything in words and symbols. Don't forget that many
of us, especially the dyslexic or textually-impaired have a hell of a
time typing in words and spelling them properly but find it easier to
arrange boxes. The reason *you* (self included) think that they are
the same thing is that you have used text so much that your brain has
physically changed to recognize textual symbols and words as meta-
symbols or graphics in their own right.
That's not the case for most people, especially non-designers.
There have been studies that show that their brains recognize words
as meaning something, but not as graphics or symbols in their own
right (I hope I am explaining this well... wish I could dig up that
paper). For most people, words are words and pictures are pictures,
and while they get the hang of the "text-as-symbols" eventually, they
need to adapt to them over time. I think this is why photographers
and graphic designers take to programming well (in my experience) -
they already have the mental toolkit for seeing the worlds as a
collection of abstract symbols laid out spatially.
The underlying metaphors of text and patching are also very
different. Pd and Max were originally designed to look like audio
control systems of the time - boxes plugged into other boxes in
series. Then came the DSP portion of them (they started out as pure
control data; MIDI) and the metaphor evolved a bit to include analog
synthesizers and their arrays of function generators and patch cables.
Where does the metaphor of textual programming come from? From laws,
codes. Mathematical logic statements, formulas. I, personally,
despise all mathematical formulas. They are designed to segregate
knowledge between those who know and understand the arcane symbols of
logic and the universe, and the unwashed who have not had
superscripts and subscripts beaten into them. Historically, math has
been the provenance of secret conspiracies, knowledge-hoarding
universities, and dueling mathematicians scrapping for credit in this
discovery or another, speaking in the codes of the elite.
Yes, the language can be elegant and succinct, but there's a reason
why many mathematicians have Platonic leanings, along with the
computer scientists who shun the nitty-gritty details of life and
visual design and bend towards the perfection of the written program,
the poetry of code. If the language of code was less elitist, it
would be more easily pronounceable - who here has had to explain the
intricacies of curly-brackets vs. open-parenthesis vs. square
brackets? It sounds like some medieval incantation.
Anyway, the funny thing is that now that I've come to the end of this
long rant, I just had an offline conversation with Dave about this,
and I think I've been intellectually nudged closer to the central
view that the real issue is about accessibility, there is less
difference between text and image (even though I reserve the view
that there is a neurological basis for treating them differently) and
the "accident" of using text to describe complex instructions
(computer programs) to machines due to typewriters being so
ubiquitous. I'll leave you with that thought...
Cheers
Evan
Received on Thu Oct 15 2009 - 14:00:37 BST