From: Ken Tilton
Subject: Here I go again: listener or observer?
Date:
Message-ID: <lljRf.23$tT2.10@fe11.lga>
Cells lets client code specify on-change callbacks per slotname (and
type of instance, new-value, and old-value).
These first were called echos, then outputs. For a day I hit it over the
head and called them change-handlers, but... ewwwww. I just changed them
all to "listener", but looking at Bill Clementson's blog entry on Cells
I see he called them observers.
Polls are open, write-ins are welcome:
def-listener
def-observer
other ________________
kt
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
Ken Tilton wrote:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over the
> head and called them change-handlers, but... ewwwww. I just changed them
> all to "listener", but looking at Bill Clementson's blog entry on Cells
> I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
Here are some other words: monitor, trigger.
If the callback is advice which can change the assignment, or possibly
elide it completely, then: advisor.
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <aMkRf.28$tT2.4@fe11.lga>
Kaz Kylheku wrote:
> Ken Tilton wrote:
>
>>Cells lets client code specify on-change callbacks per slotname (and
>>type of instance, new-value, and old-value).
>>
>>These first were called echos, then outputs. For a day I hit it over the
>>head and called them change-handlers, but... ewwwww. I just changed them
>>all to "listener", but looking at Bill Clementson's blog entry on Cells
>>I see he called them observers.
>>
>>Polls are open, write-ins are welcome:
>>
>> def-listener
>>
>> def-observer
>>
>> other ________________
>
>
> Here are some other words: monitor, trigger.
both good. well, the GoF "observer" pattern may have some mindshare, so
i'll go with that.
thx to all.
ken
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
On Mon, 13 Mar 2006 14:02:02 -0500, Ken Tilton <·········@gmail.com> wrote:
>
> [snip]
>
>Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
How about
def-subscriber
--
Jack Unrue
in message <···············@fe11.lga>, Ken Tilton (··········@gmail.com')
wrote:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over
> the head and called them change-handlers, but... ewwwww. I just changed
> them all to "listener", but looking at Bill Clementson's blog entry on
> Cells I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
Setters and getters.
--
·····@jasmine.org.uk (Simon Brooke) http://www.jasmine.org.uk/~simon/
;; Men never do evil so completely and cheerfully as when they
;; do it from religious conviction." -- Pascal
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <ZKkRf.27$tT2.7@fe11.lga>
Simon Brooke wrote:
> in message <···············@fe11.lga>, Ken Tilton (··········@gmail.com')
> wrote:
>
>
>>Cells lets client code specify on-change callbacks per slotname (and
>>type of instance, new-value, and old-value).
>>
>>These first were called echos, then outputs. For a day I hit it over
>>the head and called them change-handlers, but... ewwwww. I just changed
>>them all to "listener", but looking at Bill Clementson's blog entry on
>>Cells I see he called them observers.
>>
>>Polls are open, write-ins are welcome:
>>
>> def-listener
>>
>> def-observer
>>
>> other ________________
>
>
> Setters and getters.
>
No, this is not about setting and getting. This is about slots taking on
new values, perhaps because their rules get icked off again. I do not go
thru a setter to install the new value because I want to limit SETF
strictly to just a few cells that serve as inputs of the overall model
(this is how OS events affect the model).
ken
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
Ken Tilton wrote:
> No, this is not about setting and getting. This is about slots taking on
> new values, perhaps because their rules get icked off again.
If the slot represents a state machine, then these handlers are like
the state transition actions.
Machine goes from state S13 to S19, and you have a handler, or chain of
handlers, specific to that machine, the S13 old value and the S19 new
value.
Ergo, DEFTRANSITION? DEFACTION?
The handlers do become in effect actions done by a given slot. For
instance a parser state machine be implemented by a token slot whose
parsing is triggered by the arrival of a new current token which gets
stored.
By the way, if DEFINE is shortened to DEF, isn't it customary to avoid
the dash?
DEFUN, DEFMACRO, DEFMETHOD, DEFSETF
versus
DEFINE-SYMBOL-MACRO, DEFINE-COMPILER-MACRO,
DEFINE-SETF-EXPANDER.
So it's either DEFOBSERVER or DEFINE-OBSERVER.
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <SRlRf.116$v27.38@fe08.lga>
Kaz Kylheku wrote:
> Ken Tilton wrote:
>
>>No, this is not about setting and getting. This is about slots taking on
>>new values, perhaps because their rules get kicked off again.
>
>
> If the slot represents a state machine, then these handlers are like
> the state transition actions.
no, the cell /rules/ do that. the babies i am describing are defined per
slotname and are more in the spirit of :after methods on SETF <writer>,
having no effect on the slot change (unless they backtrace <g>).
these really are observers, kicked off as optional callbacks to give the
model an opportunity to have some side effect outside the system. For
example, if a widget changes color, in some OSes the screen footprint of
the widget was be "invalidated" to achieve a redraw. With Celtk, hell,
every time a slot changes we have to tell Tk to reconfigure the widget
(in my implementation, CLOS instances map one-to-one (uh, almost) to Tk
widgets, including slots to configuration options).
>
> Machine goes from state S13 to S19, and you have a handler, or chain of
> handlers, specific to that machine, the S13 old value and the S19 new
> value.
>
> Ergo, DEFTRANSITION? DEFACTION?
>
> The handlers do become in effect actions done by a given slot. For
> instance a parser state machine be implemented by a token slot whose
> parsing is triggered by the arrival of a new current token which gets
> stored.
>
> By the way, if DEFINE is shortened to DEF, isn't it customary to avoid
> the dash?
You might be right, i never picked that one up. Lessee what the old
hands have to say.
ken
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
I of course like define-change-method, but failing that defobserver is nice.
Ken Tilton <·········@gmail.com> writes:
> Kaz Kylheku wrote:
> > By the way, if DEFINE is shortened to DEF, isn't it customary to
> > avoid
> > the dash?
>
> You might be right, i never picked that one up. Lessee what the old
> hands have to say.
Oh, and here I thought this was an intentional Kenny-ism. The topic
has come up a few times over the years, and AFAICT there are two
groups: those who use maintain a distinction, using defword and
define-longer-phrase; and those who don't pay much attention and use
defword, def-word, def-longer-phrase, define-word, and
define-longer-phrase at will. For example, SBCL is of the former
type, CMUCL is of the latter, IIRC Allegro is of the former, and KMP
seems to be of the latter, while tending a bit towards the former.
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <QUtRf.2272$7o7.210@fe09.lga>
Thomas F. Burdick wrote:
> I of course like define-change-method, but failing that defobserver is nice.
PWUAHAHAHAHA... I kept meaning to type defobserver to see if it looked
better than def-observer. Omigod! defobserver in a runaway.
Well, I guess I did not try it because I just assumed it would look like
de-fob-server, but clearly years of Lisp have shaped my neural parser.
Dewey Wins! (defobserver it is)
kt
>
> Ken Tilton <·········@gmail.com> writes:
>
>
>>Kaz Kylheku wrote:
>>
>>>By the way, if DEFINE is shortened to DEF, isn't it customary to
>>>avoid
>>>the dash?
>>
>>You might be right, i never picked that one up. Lessee what the old
>>hands have to say.
>
>
> Oh, and here I thought this was an intentional Kenny-ism.
Well lessee, defecho. Damn, that would have worked, too. :(
kt
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <8AuRf.154$v27.91@fe08.lga>
Ken Tilton wrote:
> Thomas F. Burdick wrote:
>
>> I of course like define-change-method,...
Of course. why? :)
>> but failing that defobserver is
>> nice.
defobserver it is (or has been for the last twenty minutes) but there is
an alternative. the macro was always meant to be just syntactic sugar
for the gf, and in Cells3 it is because I am exporting the GF:
(defmethod slot-value-observe progn
(slotname self newvalue oldvalue oldvalueboundp)
....)
I started to call it slot-value-change, but that sounds as if it is
(setf slot-value).
kt
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
Ken Tilton <·········@gmail.com> writes:
> Ken Tilton wrote:
> > Thomas F. Burdick wrote:
> >
> >> I of course like define-change-method,...
>
> Of course. why? :)
The "of course" part because I've suggested it before :-)
Why because I think it best says exactly what you're defining, a
method on change.
> defobserver it is (or has been for the last twenty minutes) but there
> is an alternative. the macro was always meant to be just syntactic
> sugar for the gf, and in Cells3 it is because I am exporting the GF:
>
> (defmethod slot-value-observe progn
> (slotname self newvalue oldvalue oldvalueboundp)
> ....)
>
> I started to call it slot-value-change, but that sounds as if it is
> (setf slot-value).
I suppose if nothing else, the move from Cells 2 to Cells 3 instead of
Cells 2.1 is justified by the incompatible API change :-)
--
/|_ .-----------------------.
,' .\ / | Free Mumia Abu-Jamal! |
,--' _,' | Abolish the racist |
/ / | death penalty! |
( -. | `-----------------------'
| ) |
(`-. '--.)
`. )----'
On 4577 September 1993, Thomas F. Burdick wrote:
> Ken Tilton <·········@gmail.com> writes:
>> Ken Tilton wrote:
>> > Thomas F. Burdick wrote:
>> >> I of course like define-change-method,...
>> Of course. why? :)
> Why because I think it best says exactly what you're defining, a
> method on change.
To me, define-change method is just a "change-method", not
a "*on*-change-do-method" (stars for emphasis only).
I would instead argue that 'Observer' is quite a common design pattern
(see the GoF book) which seems to exactly capture what is intended
here, if I understand Kenny correctly. Hence, defobserver sure sounds
like the best name to me.
>> I started to call it slot-value-change, but that sounds as if it is
>> (setf slot-value).
Not even having looked at Cells for one minute, I would also think
that s-v-c is not about observing a change, but performing the change.
Holger
--
--- http://www.coling.uni-freiburg.de/~schauer/ ---
Fachbegriffe der Informatik - Einfach erkl�rt
6: Globale Variable
Parameter�bergabemechanismus in 4GLs (Marit K�hntopp)
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <kuBRf.918$5e4.751@fe08.lga>
Thomas F. Burdick wrote:
> Ken Tilton <·········@gmail.com> writes:
>
>
>>Ken Tilton wrote:
>>
>>>Thomas F. Burdick wrote:
>>>
>>>
>>>>I of course like define-change-method,...
>>
>>Of course. why? :)
>
>
> The "of course" part because I've suggested it before :-)
>
> Why because I think it best says exactly what you're defining, a
> method on change.
Yeah, but it still sounds as if that could affect the change to the
slot. Need "on-change" or something to signify the observer or
subscribe/notify pattern.
>
>
>>defobserver it is (or has been for the last twenty minutes) but there
>>is an alternative. the macro was always meant to be just syntactic
>>sugar for the gf, and in Cells3 it is because I am exporting the GF:
>>
>>(defmethod slot-value-observe progn
>> (slotname self newvalue oldvalue oldvalueboundp)
>> ....)
>>
>>I started to call it slot-value-change, but that sounds as if it is
>>(setf slot-value).
>
>
> I suppose if nothing else, the move from Cells 2 to Cells 3 instead of
> Cells 2.1 is justified by the incompatible API change :-)
>
<g> The justification is that you will not /port/ existing code to
Cells3 until you are in the mood for a lot of work and re-testing.
Big New Stuff:
- the client task queue, and an optional client task queue handler. This
lets observers (which get kicked off in the usual random Cells order)
queue side-effects in which, say, Tk will learn what is going on in
Lispville, so the handler can (at the end of datapulse handling) sort
them into the order Tk requires.
- evil observer SETFs now /must/ be wrapped in with-integrity so they
get deferred. Hmmm, maybe I should have had a setf-queue-handler, too.
Anyway, this lets you get the whole observer form deferred so you do not
get that old-data, new-data problem that set this whole thing in motion.
- parents must now be specified to make-instance (if at all). no more
special-handling for .kids. In fact, dynamic model population is now
generalized beyond the kids slot. The application is responsible only
for calling not-to-be on an instance; to-be and make-be sleep with the
fish.
- State change can now be understood. :) It goes like this:
tell dependents
awaken any new instances (activate and observe all cells)
process client queue
reset ephemerals
process queued setfs (doing all the above recursively for each)
Where are the observers? They get called as now on any state change, but
the only thing they should do when called is (a) queue client/setf tasks
and (b) operate truly outside the model (such as invalidating a region
of the screen in some GUIs). sho who cares?
- users are now notified in the order they asked for a value. Not sure
how this changes anything (and nothing broke), but it just seemed right.
2.1? What I see is that the decimal thing is a slippery slope. Once one
starts using it, nothing ever seems to justify moving to the next units
increment.
Also, by moving to the next whole unit, I can charge more for the upgrade.
kt
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
Ken Tilton wrote:
>
> I started to call it slot-value-change, but that sounds as if it is
> (setf slot-value).
>
Given the amount of bandwidth consumed by this issue, it must be of
great import.
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <gUGRf.933$5e4.313@fe08.lga>
Just as the thread was dying out, Joe Marshall wrote:
> Ken Tilton wrote:
>
>>I started to call it slot-value-change, but that sounds as if it is
>>(setf slot-value).
>>
>
>
> Given the amount of bandwidth consumed by this issue, it must be of
> great import.
>
Are you concerned that the discussion of headscarves in French schools
is getting squeezed out? :)
Clearly you have not learned Tilton' Law: "Spend more time on the
selection of the names than on the algorithm."
I think I have told this one before, the project I took over from a
wunderkind who had used, I kid you not, the variables aa, bb, cc, and
dd. When I howled at him he maintained they were all temporary variables
of no import. Anyway, I could not follow the code so I studied each one
and changed it to what (it turned out) it was consistently being used
for. They were not really throwaway temps. Finally, as I did the global
replace on dd, a line of code suddenly read something as bad as:
duration = stop-time
I called the wunderkind over and said, WTF? He exlaimed, Oh! I never
could find that bug! He had actually knowing left behind a bug. The bad
names were so obstructive that, bright as he was (he was), he actually
gave up on finding the bug.
And of course the punch line is that I did not even know there was a
bug, but the right names made the code impossible to believe.
As Confucius said when asked what he would do if made Emperor, "First we
correct the names."
Don't forget, Cells will soon dominate software development, so you will
be living with these names for a lonnnggg time.
kt
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
in message <··············@fe11.lga>, Ken Tilton (··········@gmail.com')
wrote:
> Simon Brooke wrote:
>> in message <···············@fe11.lga>, Ken Tilton
>> (··········@gmail.com') wrote:
>>
>>>Cells lets client code specify on-change callbacks per slotname (and
>>>type of instance, new-value, and old-value).
>>>
>>>These first were called echos, then outputs. For a day I hit it over
>>>the head and called them change-handlers, but... ewwwww. I just
>>>changed them all to "listener", but looking at Bill Clementson's blog
>>>entry on Cells I see he called them observers.
>>>
>>>Polls are open, write-ins are welcome:
>>>
>>> def-listener
>>>
>>> def-observer
>>>
>>> other ________________
>>
>> Setters and getters.
>
> No, this is not about setting and getting. This is about slots taking
> on new values, perhaps because their rules get icked off again. I do
> not go thru a setter to install the new value because I want to limit
> SETF strictly to just a few cells that serve as inputs of the overall
> model (this is how OS events affect the model).
You mistake my meaning. I deprecate SETF at the best of times. But an
active value method which polices the setting of a slot value is, in
simple language, a setter (or perhaps a maybe-setter, if there are
conditions under which it may refuse to set); and an active value method
which polices the getting of a slot value is, equally, a getter or a
maybe-getter. And note that by using the word 'method' I am not implying
CLOS or object orientation at all, but simply speaking generally - a
setter is clearly not a function, since to work it must have a side
effect.
--
·····@jasmine.org.uk (Simon Brooke) http://www.jasmine.org.uk/~simon/
;; Woz: 'All the best people in life seem to like LINUX.'
;; <URL:http://www.woz.org/woz/cresponses/response03.html>
From: Edi Weitz
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <uwtey871h.fsf@agharta.de>
On Mon, 13 Mar 2006 14:02:02 -0500, Ken Tilton <·········@gmail.com> wrote:
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
define-observer
Edi.
--
European Common Lisp Meeting 2006: <http://weitz.de/eclm2006/>
Real email: (replace (subseq ·········@agharta.de" 5) "edi")
Ken Tilton <·········@gmail.com> writes:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over the
> head and called them change-handlers, but... ewwwww. I just changed them
> all to "listener", but looking at Bill Clementson's blog entry on Cells
> I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
def-reflex
--
Alan Crowe
Ken Tilton <·········@gmail.com> writes:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over
> the head and called them change-handlers, but... ewwwww. I just
> changed them all to "listener", but looking at Bill Clementson's blog
> entry on Cells I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
Well, of course, it depends whether it has eyes or ears.
If it's blind and death, then it may try:
def-finger
def-tongue
def-nose
--
__Pascal Bourguignon__ http://www.informatimago.com/
Until real software engineering is developed, the next best practice
is to develop with a dynamic system that has extreme late binding in
all aspects. The first system to really do this in an important way
is Lisp. -- Alan Kay
Ken Tilton wrote:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over the
> head and called them change-handlers, but... ewwwww. I just changed them
> all to "listener", but looking at Bill Clementson's blog entry on Cells
> I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
>
> kt
>
def-peeping-tom
def-vicarious
def-trigger
def-change-callback
def-instinct
def-groveller
def-kick-me
def-slave
def-grunt
....
Wade
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <BDoRf.1752$7o7.795@fe09.lga>
Wade Humeniuk wrote:
> Ken Tilton wrote:
>
>> Cells lets client code specify on-change callbacks per slotname (and
>> type of instance, new-value, and old-value).
>>
>> These first were called echos, then outputs. For a day I hit it over
>> the head and called them change-handlers, but... ewwwww. I just
>> changed them all to "listener", but looking at Bill Clementson's blog
>> entry on Cells I see he called them observers.
>>
>> Polls are open, write-ins are welcome:
>>
>> def-listener
>>
>> def-observer
>>
>> other ________________
>>
>> kt
>>
>
> def-peeping-tom
> def-vicarious
> def-trigger
> def-change-callback
> def-instinct
> def-groveller
> def-kick-me
> def-slave
> def-grunt
"Dying is easy. Comedy is hard."
- Edmund kean, 1834, on his deathbed
:)
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
Ken Tilton wrote:
>>
>> def-peeping-tom
>> def-vicarious
>> def-trigger
>> def-change-callback
>> def-instinct
>> def-groveller
>> def-kick-me
>> def-slave
>> def-grunt
>
> "Dying is easy. Comedy is hard."
> - Edmund kean, 1834, on his deathbed
>
Then it should be defekean, (or maybe def-zombie)
or maybe def-spit-ball ...
or ............
def-insert^here
Anything but the boring def-observer.
Wade
From: Ken Tilton
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <75sRf.1238$MG6.437@fe10.lga>
Wade Humeniuk wrote:
> Ken Tilton wrote:
>
>>>
>>> def-peeping-tom
>>> def-vicarious
>>> def-trigger
>>> def-change-callback
>>> def-instinct
>>> def-groveller
>>> def-kick-me
>>> def-slave
>>> def-grunt
>>
>>
>> "Dying is easy. Comedy is hard."
>> - Edmund kean, 1834, on his deathbed
>>
>
> Then it should be defekean, (or maybe def-zombie)
> or maybe def-spit-ball ...
I am starting to understand how the greatest computer language in the
universe got named after a speech impediment.
:)
kt
ps. I noticed too late last time the serious offering in the middle of
the list. Considered that, but... too boring. :) k
--
Cells: http://common-lisp.net/project/cells/
"And I will know my song well before I start singing." - Bob Dylan
> I am starting to understand how the greatest computer language in the
> universe got named after a speech impediment.
>
> :)
>
> kt
>
> ps. I noticed too late last time the serious offering in the middle of the
> list. Considered that, but... too boring. :) k
>
I guess you already considered the obvious "DEF-RNA"
Sacha
From: Frank Goenninger DG1SBG
Subject: Re: Here I go again: listener or observer?
Date:
Message-ID: <m2acbtlbfj.fsf@pcsde001.local>
Ken Tilton <·········@gmail.com> writes:
> Cells lets client code specify on-change callbacks per slotname (and
> type of instance, new-value, and old-value).
>
> These first were called echos, then outputs. For a day I hit it over
> the head and called them change-handlers, but... ewwwww. I just
> changed them all to "listener", but looking at Bill Clementson's blog
> entry on Cells I see he called them observers.
>
> Polls are open, write-ins are welcome:
>
> def-listener
>
> def-observer
>
> other ________________
doccb (define-on-change-callback) ;-)
or
define-hook
When sticking to the list above is more desired I'd prefer
def-observer. A Listener is something else in Lisp context for me.
>
> kt
>
Cheers!
Frank