Re: Coding vs patching: would you eat soup with a fork?

There's this:

http://www.nici.kun.nl/mmm/papers/dh-93-b.txt

This used to be on the Cycling website but they seem to have taken it  
down. I think the thing with Max is that it was supposed to appeal to  
analog studio users, but as Ron once pointed out to me the old  
situation is reversed, with digital studio techniques now being  
'basic' and analog being 'advanced'. This rather decreases the utility  
of the patching metaphor.

I can think of a couple of things that contribute to the perception  
that max is 'easier'. The first is that Max does not constitute 'real  
programming', and that 'real programming' is hard. That's mostly  
prevalent amongst older users.

More relevant is the fact that a language like SC requires you to deal  
with levels of abstraction more immediately. This is a small hurdle to  
get over mostly, but it can seem quite intimidating. I like to give an  
example like this to people:

(
// harmonic swimming
play({
        var f, p, z, offset;
        f = 50; // fundamental frequency
        p = 20; // number of partials per channel
        z = 0.0; // start of oscil daisy chain
        offset = Line.kr(0, -0.02, 60); // causes sound to separate and fade
        p.do({ arg i; z = FSinOsc.ar(f * (i+1), 0, max(0, LFNoise1.kr(6 +  
[4.0.rand2, 4.0.rand2], 0.02, offset)), z)});
        z
}))

and show them Sciss' max like representation:






Then ask them to make p = 100 and imagine what the max patch would  
look like. That's when lights go on and people realise that the SC  
version is so elegant and expressive because of the abstraction. In  
essence it works so well because in SC you can tell the program to  
make you all these UGens, whereas in Max the visual metaphor requires  
you to 'make them' yourself.

Thus Max's appeal (the metaphor of connecting 'real world' objects,  
which exist, i.e. they are seemingly tangible and persistent) becomes  
an important limitation. Nevertheless I think for certain types of  
fast prototyping, Max can be very effective, especially if you need to  
quickly insert control (sometimes it's nice that the 'code' for a  
slider is a slider), or introspection (we've tried to make SC better  
at this with UGen:poll and scope).

It is certainly true that Max does not scale well though, and that for  
a supposedly 'high level' language, it really does allow you to shoot  
yourself in the foot with surprising ease. I find it quite fascinating  
that as Max grows it has taken on more aspects of 'real' programming  
languages (e.g. attributes), and expended a lot of effort working  
around the limitations of the visual metaphor. The biggest examples of  
this are patcher scripting, javascript, and java integration, which  
basically partially turn Max into a bunch of text based languages,  
albeit none of them as nice as SC IMO.

On a closing note, for a few years I taught classes in which students  
had to learn both Max and SC. Interestingly, on the whole the more  
'touchy-feely' intuitive types tended to gravitate towards SC, whereas  
the hard-core math types seemed to like Max. There is indeed something  
'macho' about Max and its community, despite the supposed fact that  
'real men use SuperCollider', as I once read somewhere. Ironically I  
think part of the long-term appeal of Max to power users is its  
impenetrability and poor scaling; using it allows one to display a  
certain virtuosity.

Two cents,

S.

On 24 Apr 2009, at 09:38, Uri Sala wrote: