[f $0]-[message $1( is conceptually different from [message $0( for the same reason that [f $2]-[message $1( is conceptually different from [message $2( (and would be, even if $0 had any meaning in a message box). When I teach I always start with dollar-sign expansion in message-boxes, since it's simpler and easier to comprehend. Then when this issue comes up when they move to dollar-sign expansion in abstractions (and it always does come up), you can help them think it through with what they already know about message boxes.
I only see two options: one is to use a different dereference symbol for abstraction arguments in message boxes -- but why worry with that since it's easy enough to get abstraction arguments into messages at "run-time?" -- the other is to make an exception and have special behavior for $0 in message boxes (that is, make it the same as in object boxes) -- but then this probably breaks the consistency of the language.
Matt
Date: Mon, 09 Feb 2009 13:33:36 +0100 From: Georg Werner georg@fricklr.de Subject: Re: [PD] here I go again..dynamic abstractions To: pd-list@iem.at Message-ID: 499022A0.7080702@fricklr.de Content-Type: text/plain; charset=ISO-8859-1; format=flowed
hi,
Frank Barknecht:
How about making $0 in messages be a message counter?
if somebody really needs that - i dont ;)
ok, i give up. i think we are on a rather philosophical point now. but i had a lot of times when students where asking why they have to write [f $0]-[foobar $1( instead of [foobar $0(. so this came up from a users point of view. after getting all your input (thanks). i think Claude brought up the most logical solution, because this makes the different functions of $ obvious and obsolete. And it would help users and devs. (i know it will be a long way - cause it will break some patches ... :( )
$ in message boxes is unfortunate. If there was a different symbol, perhaps #, you could combine both phases in one object box to avoid jumping through pointless hoops. [$0-#1-$2-#3( would be nice, but as Pd is now, it's a nightmare.
not a nightmare, but this is one point why Pd is harder to learn for beginners than it has to. georg
I think it would make sense (both pedagogically and practically) if $0 in message boxes actually _did_ something. Incrementing per message box would be one option, but expanding to a user-defined symbol or float could be very useful:
[loadbang] | [f $0] | [; set $0(
That way, message box $0 is set by an incoming message: it then sets all current (and future) message box $0's for the patch/abstraction. Alternatively, you could use it for other stuff, like a substitution for pd-my-complicated-and-tiresome-to-type-subpatch-name.
abstraction $0: set by pd, unique abs instance identifier, common to all object boxes message box $0: set by user through msg box, common to all abstraction instance msg's
Seems like that would be consistent with the language as far as I understand it.
-Jonathan
--- On Mon, 2/9/09, Matt Barber brbrofsvl@gmail.com wrote:
From: Matt Barber brbrofsvl@gmail.com Subject: Re: [PD] here I go again..dynamic abstractions To: "PD-List" pd-list@iem.at Date: Monday, February 9, 2009, 9:01 PM [f $0]-[message $1( is conceptually different from [message $0( for the same reason that [f $2]-[message $1( is conceptually different from [message $2( (and would be, even if $0 had any meaning in a message box). When I teach I always start with dollar-sign expansion in message-boxes, since it's simpler and easier to comprehend. Then when this issue comes up when they move to dollar-sign expansion in abstractions (and it always does come up), you can help them think it through with what they already know about message boxes.
I only see two options: one is to use a different dereference symbol for abstraction arguments in message boxes -- but why worry with that since it's easy enough to get abstraction arguments into messages at "run-time?" -- the other is to make an exception and have special behavior for $0 in message boxes (that is, make it the same as in object boxes) -- but then this probably breaks the consistency of the language.
Matt
Date: Mon, 09 Feb 2009 13:33:36 +0100 From: Georg Werner georg@fricklr.de Subject: Re: [PD] here I go again..dynamic
abstractions
To: pd-list@iem.at Message-ID: 499022A0.7080702@fricklr.de Content-Type: text/plain; charset=ISO-8859-1;
format=flowed
hi,
Frank Barknecht:
How about making $0 in messages be a message
counter?
if somebody really needs that - i dont ;)
ok, i give up. i think we are on a rather
philosophical point now.
but i had a lot of times when students where asking
why they have to
write [f $0]-[foobar $1( instead of [foobar $0(. so
this came up from a
users point of view. after getting all your input (thanks). i think Claude
brought up the
most logical solution, because this makes the
different functions of $
obvious and obsolete. And it would help users and
devs. (i know it will
be a long way - cause it will break some patches ...
:( )
$ in message boxes is unfortunate. If there was
a different symbol,
perhaps #, you could combine both phases in one
object box to avoid
jumping through pointless hoops. [$0-#1-$2-#3( would be nice, but as Pd is now,
it's a nightmare.
not a nightmare, but this is one point why Pd is
harder to learn for
beginners than it has to. georg
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
On Mon, Feb 9, 2009 at 3:45 PM, Jonathan Wilkes jancsika@yahoo.com wrote:
I think it would make sense (both pedagogically and practically) if $0 in message boxes actually _did_ something. Incrementing per message box would be one option, but expanding to a user-defined symbol or float could be very useful:
Actually, for me, I always think of the word "CONTEXT". An abstraction is one context, and the meanings of the $ args means one thing. While in a message, a $ arg means something completely different. Once I realized that the two are not the same thing, it made sense.
If the $ args had the same meanings in both an abstraction and a message, there would be no way to create a message inside of an abstraction that allowed for $ args that were unrelated to the $ args in the abstraction.
In other words, if they were the same thing, there would be no way to create a variable message that had more args than there were in the abstraction itself.
Mike
[loadbang] | [f $0] | [; set $0(
That way, message box $0 is set by an incoming message: it then sets all current (and future) message box $0's for the patch/abstraction. Alternatively, you could use it for other stuff, like a substitution for pd-my-complicated-and-tiresome-to-type-subpatch-name.
abstraction $0: set by pd, unique abs instance identifier, common to all object boxes message box $0: set by user through msg box, common to all abstraction instance msg's
Seems like that would be consistent with the language as far as I understand it.
-Jonathan
--- On Mon, 2/9/09, Matt Barber brbrofsvl@gmail.com wrote:
From: Matt Barber brbrofsvl@gmail.com Subject: Re: [PD] here I go again..dynamic abstractions To: "PD-List" pd-list@iem.at Date: Monday, February 9, 2009, 9:01 PM [f $0]-[message $1( is conceptually different from [message $0( for the same reason that [f $2]-[message $1( is conceptually different from [message $2( (and would be, even if $0 had any meaning in a message box). When I teach I always start with dollar-sign expansion in message-boxes, since it's simpler and easier to comprehend. Then when this issue comes up when they move to dollar-sign expansion in abstractions (and it always does come up), you can help them think it through with what they already know about message boxes.
I only see two options: one is to use a different dereference symbol for abstraction arguments in message boxes -- but why worry with that since it's easy enough to get abstraction arguments into messages at "run-time?" -- the other is to make an exception and have special behavior for $0 in message boxes (that is, make it the same as in object boxes) -- but then this probably breaks the consistency of the language.
Matt
Date: Mon, 09 Feb 2009 13:33:36 +0100 From: Georg Werner georg@fricklr.de Subject: Re: [PD] here I go again..dynamic
abstractions
To: pd-list@iem.at Message-ID: 499022A0.7080702@fricklr.de Content-Type: text/plain; charset=ISO-8859-1;
format=flowed
hi,
Frank Barknecht:
How about making $0 in messages be a message
counter?
if somebody really needs that - i dont ;)
ok, i give up. i think we are on a rather
philosophical point now.
but i had a lot of times when students where asking
why they have to
write [f $0]-[foobar $1( instead of [foobar $0(. so
this came up from a
users point of view. after getting all your input (thanks). i think Claude
brought up the
most logical solution, because this makes the
different functions of $
obvious and obsolete. And it would help users and
devs. (i know it will
be a long way - cause it will break some patches ...
:( )
$ in message boxes is unfortunate. If there was
a different symbol,
perhaps #, you could combine both phases in one
object box to avoid
jumping through pointless hoops. [$0-#1-$2-#3( would be nice, but as Pd is now,
it's a nightmare.
not a nightmare, but this is one point why Pd is
harder to learn for
beginners than it has to. georg
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
This has been an interesting discussion about the philosophy behind dollar-sign symbols in Pd, but it seems to me like most participants are talking around Georg's original point at the head of the thread: it's inconvenient to get $0 (the "unique-id-for-this-abstraction" value) into a message, and its exclusion from message boxes seems arbitrary.
Why arbitrary? It's very clear that dollar symbols mean different
things in messages than they do in abstractions -- that is not the
issue. In fact, $0 is a special case *when used as an abstraction
parameter* as well -- it does not have anything close to the same
meaning or function as $1, $2, etc. (i.e., initialization parameters).
Yet, it is still allowed in abstractions. Why does the same reasoning
not hold for message boxes? It is a perfectly valid use-case to send an
abstraction-id (from the message's containing abstraction) in a message.
This whole question might have been avoided if $0 did not start with a dollar sign (I think someone mentioned this already). But just because it does, why is it excluded from message boxes? At least one other response in this thread has gone so far as to suggest that since $0 doesn't have any meaning in a message box, it should be overloaded for something else (other than the unique abstraction identifier). No, please! :-) Despite all the discussion in this thread, I have yet to see a reason for this exclusion that wouldn't apply equally to using $0 as an abstraction-id.
Phil Stone pkstonemusic.com
Mike McGonagle wrote:
On Mon, Feb 9, 2009 at 3:45 PM, Jonathan Wilkes jancsika@yahoo.com wrote:
I think it would make sense (both pedagogically and practically) if $0 in message boxes actually _did_ something. Incrementing per message box would be one option, but expanding to a user-defined symbol or float could be very useful:
Actually, for me, I always think of the word "CONTEXT". An abstraction is one context, and the meanings of the $ args means one thing. While in a message, a $ arg means something completely different. Once I realized that the two are not the same thing, it made sense.
If the $ args had the same meanings in both an abstraction and a message, there would be no way to create a message inside of an abstraction that allowed for $ args that were unrelated to the $ args in the abstraction.
In other words, if they were the same thing, there would be no way to create a variable message that had more args than there were in the abstraction itself.
Mike
[loadbang] | [f $0] | [; set $0(
That way, message box $0 is set by an incoming message: it then sets all current (and future) message box $0's for the patch/abstraction. Alternatively, you could use it for other stuff, like a substitution for pd-my-complicated-and-tiresome-to-type-subpatch-name.
abstraction $0: set by pd, unique abs instance identifier, common to all object boxes message box $0: set by user through msg box, common to all abstraction instance msg's
Seems like that would be consistent with the language as far as I understand it.
-Jonathan
--- On Mon, 2/9/09, Matt Barber brbrofsvl@gmail.com wrote:
From: Matt Barber brbrofsvl@gmail.com Subject: Re: [PD] here I go again..dynamic abstractions To: "PD-List" pd-list@iem.at Date: Monday, February 9, 2009, 9:01 PM [f $0]-[message $1( is conceptually different from [message $0( for the same reason that [f $2]-[message $1( is conceptually different from [message $2( (and would be, even if $0 had any meaning in a message box). When I teach I always start with dollar-sign expansion in message-boxes, since it's simpler and easier to comprehend. Then when this issue comes up when they move to dollar-sign expansion in abstractions (and it always does come up), you can help them think it through with what they already know about message boxes.
I only see two options: one is to use a different dereference symbol for abstraction arguments in message boxes -- but why worry with that since it's easy enough to get abstraction arguments into messages at "run-time?" -- the other is to make an exception and have special behavior for $0 in message boxes (that is, make it the same as in object boxes) -- but then this probably breaks the consistency of the language.
Matt
Date: Mon, 09 Feb 2009 13:33:36 +0100 From: Georg Werner georg@fricklr.de Subject: Re: [PD] here I go again..dynamic
abstractions
To: pd-list@iem.at Message-ID: 499022A0.7080702@fricklr.de Content-Type: text/plain; charset=ISO-8859-1;
format=flowed
hi,
Frank Barknecht:
How about making $0 in messages be a message
counter?
if somebody really needs that - i dont ;)
ok, i give up. i think we are on a rather
philosophical point now.
but i had a lot of times when students where asking
why they have to
write [f $0]-[foobar $1( instead of [foobar $0(. so
this came up from a
users point of view. after getting all your input (thanks). i think Claude
brought up the
most logical solution, because this makes the
different functions of $
obvious and obsolete. And it would help users and
devs. (i know it will
be a long way - cause it will break some patches ...
:( )
$ in message boxes is unfortunate. If there was
a different symbol,
perhaps #, you could combine both phases in one
object box to avoid
jumping through pointless hoops. [$0-#1-$2-#3( would be nice, but as Pd is now,
it's a nightmare.
not a nightmare, but this is one point why Pd is
harder to learn for
beginners than it has to. georg
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
Oops, I screwed up that ascii art patch. It should be more like this:
[loadbang] | [f $0] | [; set dollarzero $1(
-Jonathan
--- On Mon, 2/9/09, Matt Barber brbrofsvl@gmail.com wrote:
From: Matt Barber brbrofsvl@gmail.com Subject: Re: [PD] here I go again..dynamic abstractions To: "PD-List" pd-list@iem.at Date: Monday, February 9, 2009, 9:01 PM [f $0]-[message $1( is conceptually different from [message $0( for the same reason that [f $2]-[message $1( is conceptually different from [message $2( (and would be, even if $0 had any meaning in a message box). When I teach I always start with dollar-sign expansion in message-boxes, since it's simpler and easier to comprehend. Then when this issue comes up when they move to dollar-sign expansion in abstractions (and it always does come up), you can help them think it through with what they already know about message boxes.
I only see two options: one is to use a different dereference symbol for abstraction arguments in message boxes -- but why worry with that since it's easy enough to get abstraction arguments into messages at "run-time?" -- the other is to make an exception and have special behavior for $0 in message boxes (that is, make it the same as in object boxes) -- but then this probably breaks the consistency of the language.
Matt
Date: Mon, 09 Feb 2009 13:33:36 +0100 From: Georg Werner georg@fricklr.de Subject: Re: [PD] here I go again..dynamic
abstractions
To: pd-list@iem.at Message-ID: 499022A0.7080702@fricklr.de Content-Type: text/plain; charset=ISO-8859-1;
format=flowed
hi,
Frank Barknecht:
How about making $0 in messages be a message
counter?
if somebody really needs that - i dont ;)
ok, i give up. i think we are on a rather
philosophical point now.
but i had a lot of times when students where asking
why they have to
write [f $0]-[foobar $1( instead of [foobar $0(. so
this came up from a
users point of view. after getting all your input (thanks). i think Claude
brought up the
most logical solution, because this makes the
different functions of $
obvious and obsolete. And it would help users and
devs. (i know it will
be a long way - cause it will break some patches ...
:( )
$ in message boxes is unfortunate. If there was
a different symbol,
perhaps #, you could combine both phases in one
object box to avoid
jumping through pointless hoops. [$0-#1-$2-#3( would be nice, but as Pd is now,
it's a nightmare.
not a nightmare, but this is one point why Pd is
harder to learn for
beginners than it has to. georg
Pd-list@iem.at mailing list UNSUBSCRIBE and account-management -> http://lists.puredata.info/listinfo/pd-list
Hallo, Matt Barber hat gesagt: // Matt Barber wrote:
I only see two options:
I see a third option: $0 is not only different from the $-variables in message boxes, but it's also different from the $-variables used as object arguments.[1] So another way out would be to replace only "$0" with something like "#0". Of course beginners then still would like to use #0 in a message box.
[1] Actually the $-variables 1,2,3,... in message boxes and those in object boxes aren't that different, because the contents of object boxes also are messages to Pd's objectmaker and they are used explicitely as messages when doing dynamic patching.
Ciao
Frank Barknecht Do You RjDj.me? _ ______footils.org__
Quoting "Frank Barknecht" fbar@footils.org:
Hallo, Matt Barber hat gesagt: // Matt Barber wrote:
I only see two options:
I see a third option: $0 is not only different from the $-variables in message boxes, but it's also different from the $-variables used as object arguments.[1] So another way out would be to replace only "$0" with something like "#0". Of course beginners then still would like to use #0 in a message box.
i always thought that $0 was a misnomer, as it has nothing to do with
what $1,... means.
the logical thing would be $0=abstractionname/msesageselector and have
something else be the unique abstraction id.
but who would be willing to change that?
fgam IOhannes
This message was sent using IMP, the Internet Messaging Program.
Frank Barknecht wrote:
I see a third option: $0 is not only different from the $-variables in message boxes, but it's also different from the $-variables used as object arguments.[1] So another way out would be to replace only "$0" with something like "#0".
Yes. This, at least, would end the irrelevant "dollar sign variables
in message boxes are different than abstraction initializers" argument
every time someone asks why $0 can't be used in a message box. :-)
Also, it would be much less confusing in general, because $0 never means
the same thing as $1...$n, inside *or* outside of message boxes.
Of course beginners then still would like to use #0 in a message box.
I'm not a beginner (though far from an expert), and I still want to use the unique identifier in message boxes. What, exactly, is wrong with that use case? Frank, I think you make quite a bit of use of $0 in messages in [memento], for example. If it's wrong, why does the idiom;
[f $0]-[message $1(
get suggested as a solution so often? In my opinion, that's just a kludge, avoiding the original problem.
Looking back on the thread, I see this from Iohannes:
$-args in message-boxes are a way to modify messages. since messages don't have a patch-context, neither have (their
patchable instances) message-boxes.
But the message-boxes *do* have a patch context; they live in an abstraction that has a unique identifier, which is sometimes useful to blend into a message.
I'm sorry for being stubborn about this, but I still don't see Georg's basic question answered, just a lot of dancing around it. :-)
Phil
-
Frank Barknecht -
Jonathan Wilkes -
Matt Barber -
Mike McGonagle -
Phil Stone -
zmoelnig＠iem.at