Vancouver, BC : Lispers Take Note!
I convinced Guy Lancaster, who runs the monthly software developers
meetup here, to invite Gregor Kiczales to speak. Co-author of _The Art
of the Meta Object Protocol_ and the original developer of Portable
Common Loops (from which most CLOS implemetations are based), he is now
doing work with Aspect Oriented Programming (AspectJ).
This is only the third meetup, and it's the second with some lisp
content (i spoke at the first), so any vancouver lispers should come out.
He plans to talk mostly about AOP and AspectJ, but if i can get a few
more lispnicks there, we can grill him on AMOP and PCL...
Here are the details :
We open this meeting with a presentation by Prof. Gregor Kiczales of
UBC's Software Practices Lab about his work with aspect-oriented
programming and AspectJ. We'll follow this with questions, a round of
introductions, and open discussion. This is a networking event so bring
your business cards and find out from each other who's doing what in
Vancouver.
When:
Tuesday, January 11, 2005 at 7:00 PM
Where:
UBC Robson Square C550
800 Robson Steet
Vancouver, BC V6Z 3B7
604.822.3333
Map
Notes:
Aspect-oriented programming (AOP) is designed to address limitations
that object-oriented programming has with requirements that don't fit
into narrowly focussed objects. AOP supports a simple, natural
implementation of behavior that crosscuts a set of objects. The
presentation will introduce AOP in general and the AspectJ
implementation in particular.
Now with UBC's Software Practices Lab (see
http://www.cs.ubc.ca/labs/spl/ ), Gregor Kiczales was doing research on
AOP since the mid 1990's as a member of the Xerox Palo Alto Research
Center and on object-oriented programming before that. He is a
recognized authority on AOP and will be able to give us a clear
perspective on how we can use this powerful tool.
For more information on Gregor Kiczales see his homepage at
http://www.cs.ubc.ca/~gregor/ .
Hope to see you all there.
drewc
drewc wrote:
I will of course be taking notes and pictures, and i'll post them all
here for everybody to enjoy. I'm really looking forward to this.
drewc
> Vancouver, BC : Lispers Take Note!
>
> I convinced Guy Lancaster, who runs the monthly software developers
> meetup here, to invite Gregor Kiczales to speak. Co-author of _The Art
> of the Meta Object Protocol_ and the original developer of Portable
> Common Loops (from which most CLOS implemetations are based), he is now
> doing work with Aspect Oriented Programming (AspectJ).
>
> This is only the third meetup, and it's the second with some lisp
> content (i spoke at the first), so any vancouver lispers should come out.
>
> He plans to talk mostly about AOP and AspectJ, but if i can get a few
> more lispnicks there, we can grill him on AMOP and PCL...
>
> Here are the details :
>
> We open this meeting with a presentation by Prof. Gregor Kiczales of
> UBC's Software Practices Lab about his work with aspect-oriented
> programming and AspectJ. We'll follow this with questions, a round of
> introductions, and open discussion. This is a networking event so bring
> your business cards and find out from each other who's doing what in
> Vancouver.
>
> When:
> Tuesday, January 11, 2005 at 7:00 PM
>
> Where:
> UBC Robson Square C550
> 800 Robson Steet
> Vancouver, BC V6Z 3B7
> 604.822.3333
> Map
>
> Notes:
> Aspect-oriented programming (AOP) is designed to address limitations
> that object-oriented programming has with requirements that don't fit
> into narrowly focussed objects. AOP supports a simple, natural
> implementation of behavior that crosscuts a set of objects. The
> presentation will introduce AOP in general and the AspectJ
> implementation in particular.
>
> Now with UBC's Software Practices Lab (see
> http://www.cs.ubc.ca/labs/spl/ ), Gregor Kiczales was doing research on
> AOP since the mid 1990's as a member of the Xerox Palo Alto Research
> Center and on object-oriented programming before that. He is a
> recognized authority on AOP and will be able to give us a clear
> perspective on how we can use this powerful tool.
>
> For more information on Gregor Kiczales see his homepage at
> http://www.cs.ubc.ca/~gregor/ .
>
> Hope to see you all there.
>
> drewc
drewc <·····@rift.com> writes:
> Vancouver, BC : Lispers Take Note!
>
> I convinced Guy Lancaster, who runs the monthly software developers
> meetup here, to invite Gregor Kiczales to speak. Co-author of _The Art
> of the Meta Object Protocol_ and the original developer of Portable
> Common Loops (from which most CLOS implemetations are based), he is
> now doing work with Aspect Oriented Programming (AspectJ).
> He plans to talk mostly about AOP and AspectJ, but if i can get a
> few more lispnicks there, we can grill him on AMOP and PCL...
Or, to bridge the gap, ask him to talk about stuff in AspectJ that has
no analog in CLOS and the MOP. I'd also be interested to know if he's
heard of AspectL and, if so, what he thinks of it. (Basically what I
really want to know is if he still has a soft spot in his heart for
Lisp and has simply moved to Java because that's where the mass of
programmers are or if he's actually gone to the dark side. ;-))
-Peter
--
Peter Seibel ·····@javamonkey.com
Lisp is the red pill. -- John Fraser, comp.lang.lisp
Peter Seibel <·····@javamonkey.com> writes:
> drewc <·····@rift.com> writes:
>
> > Vancouver, BC : Lispers Take Note!
> >
> > I convinced Guy Lancaster, who runs the monthly software developers
> > meetup here, to invite Gregor Kiczales to speak. Co-author of _The Art
> > of the Meta Object Protocol_ and the original developer of Portable
> > Common Loops (from which most CLOS implemetations are based), he is
> > now doing work with Aspect Oriented Programming (AspectJ).
>
> > He plans to talk mostly about AOP and AspectJ, but if i can get a
> > few more lispnicks there, we can grill him on AMOP and PCL...
>
> Or, to bridge the gap, ask him to talk about stuff in AspectJ that has
> no analog in CLOS and the MOP. I'd also be interested to know if he's
> heard of AspectL and, if so, what he thinks of it. (Basically what I
> really want to know is if he still has a soft spot in his heart for
> Lisp and has simply moved to Java because that's where the mass of
> programmers are or if he's actually gone to the dark side. ;-))
I'd be curious to know what he thinks of AspectL, too. I gathered
from his talk at ILC2003 that he does still have a soft spot for Lisp,
and he wants to communicate get what he thinks are the important
insights from AspectJ to the Lisp community, and see where we take them.
Peter Seibel wrote:
> drewc <·····@rift.com> writes:
>
>>He plans to talk mostly about AOP and AspectJ, but if i can get a
>>few more lispnicks there, we can grill him on AMOP and PCL...
>
>
> Or, to bridge the gap, ask him to talk about stuff in AspectJ that has
> no analog in CLOS and the MOP. I'd also be interested to know if he's
> heard of AspectL and, if so, what he thinks of it. (Basically what I
> really want to know is if he still has a soft spot in his heart for
> Lisp and has simply moved to Java because that's where the mass of
> programmers are or if he's actually gone to the dark side. ;-))
Well, that's what i meant by 'grill him' ;) .. i am curious as to why he
is using java and the AMOP/AOP connection.
Since i Am acting as the Unofficial C.L.L representative, If there are
any specific questions anybody may have, just post them here.
I also may try to record the talk in some way, if anybody is interested.
drewc
Peter Seibel wrote:
> drewc <·····@rift.com> writes:
>
>>Vancouver, BC : Lispers Take Note!
>>
>>I convinced Guy Lancaster, who runs the monthly software developers
>>meetup here, to invite Gregor Kiczales to speak. Co-author of _The Art
>>of the Meta Object Protocol_ and the original developer of Portable
>>Common Loops (from which most CLOS implemetations are based), he is
>>now doing work with Aspect Oriented Programming (AspectJ).
>
>>He plans to talk mostly about AOP and AspectJ, but if i can get a
>>few more lispnicks there, we can grill him on AMOP and PCL...
>
> Or, to bridge the gap, ask him to talk about stuff in AspectJ that has
> no analog in CLOS and the MOP. I'd also be interested to know if he's
> heard of AspectL and, if so, what he thinks of it.
He probably hasn't heard of AspectL yet (I'd be surprised). He has heard
about my dflet stuff that came before AspectL, and he thinks that
dynamically scoped functions are too limited and are not at the heart of
AOP. I disagree, but this is probably not the right place to discuss it.
Things that are in AspectJ but not in CLOS or its MOP:
- A join point model. Join points are events in the control flow of a
program (the call of a method, the execution of a method, the return of
a method, the creation of an object, the throw of an execption, etc.)
- A special kind of join point is the cflow construct. cflow stands for
"control flow" and says something like "whenever the program is in the
control flow of some method". This is very closely related to dynamic
scoping. (It's easy to achieve cflow stuff once you have dynamically
scoped functions, but that's not the main anchor for my dflet approach!)
- A pointcut language. It offers a declarative way to pick out a set of
join points from a program. ("All the executions of methods that access
the fields of objects of class XYZ.")
- Before/after/around advices. These are similar to before/after/around
methods in CLOS, but in AspectJ they can decorate arbitrary pointcut
expressions.
AspectJ doesn't have a MOP. (It could have one, of course, but I don't
know of any.) I'd still say that AspectJ is metaprogramming (because of
the pointcut language) but Kiczales's claim is that it isn't. Obivously,
the idea was to make some typical metaobject-protocol idioms available
as base language features.
> (Basically what I
> really want to know is if he still has a soft spot in his heart for
> Lisp and has simply moved to Java because that's where the mass of
> programmers are or if he's actually gone to the dark side. ;-))
It seems to me that he thinks that Java is just the simpler language...
Pascal
--
The big bang way only works for god, everybody else has to use
evolution. - David Moon
Pascal Costanza <········@web.de> writes:
> Things that are in AspectJ but not in CLOS or its MOP:
Okay. So can you annotate this list with an equally brief summary of
how (if at all) AspectL adds these things to Common Lisp?
> - A join point model. Join points are events in the control flow of a
> program (the call of a method, the execution of a method, the return
> of a method, the creation of an object, the throw of an execption,
> etc.)
>
> - A special kind of join point is the cflow construct. cflow stands
> for "control flow" and says something like "whenever the program is
> in the control flow of some method". This is very closely related to
> dynamic scoping. (It's easy to achieve cflow stuff once you have
> dynamically scoped functions, but that's not the main anchor for my
> dflet approach!)
>
> - A pointcut language. It offers a declarative way to pick out a set
> of join points from a program. ("All the executions of methods that
> access the fields of objects of class XYZ.")
>
> - Before/after/around advices. These are similar to
> before/after/around methods in CLOS, but in AspectJ they can
> decorate arbitrary pointcut expressions.
-Peter
--
Peter Seibel ·····@javamonkey.com
Lisp is the red pill. -- John Fraser, comp.lang.lisp
Peter Seibel wrote:
> Pascal Costanza <········@web.de> writes:
>
>>Things that are in AspectJ but not in CLOS or its MOP:
>
> Okay. So can you annotate this list with an equally brief summary of
> how (if at all) AspectL adds these things to Common Lisp?
I have organized things a little bit differently. AspectL has the
following ingredients:
- Generic pointcuts: In AspectL, a generic pointcut is similar to a
generic function. Just as you can add and remove methods to a generic
function, you can add and remove both "join points" and "aspect weavers"
to a generic pointcut. A join point is (usually) a method and an aspect
weaver is a piece of code that defines (usually) a before/after/around
method on an arbitrary method. Whenever you add a join point to a gp,
all aspect weavers are applied, and whenever you add an aspect weaver,
it is applied to all join points.
There is no dedicated pointcut language to pick out join points from a
program. Just use loop, iterate, series, generalized comprehensions, or
whatever you like. ;)
BTW, I am not convinced anymore that pointcuts are actually a good idea,
neither in AspectJ nor in AspectL. You can have most of the
functionality already with macros, and the little delta that is added
with pointcuts and "weaving" is probably too little. Gregor Kiczales
admitted the close relationship to macros in a recent SD magazine
article. (People who are attending his talk should probably read that
article.)
[Macros are not "oblivious" - i.e., you have to mention them in the
"base" code when you want to use them, whereas AOP approaches allow you
to force additional code on otherwise unprepared code. I don't think
that this works in practice, though. On the other hand, AspectJ +
meta-annotations as have been added to JDK 5 could actually be used as a
macro system, and that's probably as far as you can get in a language
with a very irregular syntax...]
- Destructive mixins: They allow you to add and remove direct slots,
change the list of direct superclasses, or modify other class options,
without the need to repeat the whole class definition, as is the case in
plain CLOS. I have added them in order to match what AspectJ calls
"introductions". They are a way to add fields and methods to an existing
Java class without the need to actually change that class. In CLOS, you
can already do this with methods because they don't belong to any class
anyway. I am not sure whether destructive mixins are really useful or
not. (I'd appreciate any feedback here and also with regard to the other
AspectL features.)
- The dletf framework. That's just a proper implementation of what is
also known as letf, without the drawbacks of other implementations. (So
dletf allows you add dynamic scoping to more or less anything.)
This is not related to AOP or AspectJ, just the basis for the next two
features.
- Special classes are classes that may have special slots. Special slots
are like standard slots, but you can rebind them with dletf (without
affecting other threads). Again, not really related to AOP, but probably
very useful.
- Special functions are generic functions whose methods can be added or
changed with dynamic scope. They are a generalization of my former DSF
stuff which worked only for "normal" functions. Special functions allow
you to implement cflow functionality and avoid the need to recompile a
whole program just to add new aspectual behavior, as is the case for
AspectJ.
[I have plans to throw out generic pointcuts and destructive mixins and
focus on the latter part - dynamic scoping for everything...]
OK, I hope this helps...
Pascal
--
The big bang way only works for god, everybody else has to use
evolution. - David Moon