Re: Scope of AOP..

> -----Original Message-----
> From: Pascal Costanza [mailto:[email protected]] 
> Sent: Saturday, April 08, 2006 7:04 AM
> To: [email protected]
> Cc: [email protected]; 'Alfred V. Aho'
> Subject: Re: [aosd-discuss] Scope of AOP..
> 
> 
> On 7 Apr 2006, at 20:13, [email protected] wrote:
> 
> >> What makes logging and tracing so different that you think 
> they have
> >> to be implemented using different mechanisms?
> >
> > That's precisely my point.  They are only different insofar as
> > AspectJ-like languages requires us to treat them differently.  Any  
> > other
> > perspective on the system (e.g., requirements, design, base  
> > programmer)
> > probably treats them the same.  To implement tracing in AspectJ-like
> > languages you just use a call pointcut.  However, to implement  
> > logging the
> > approaches are a) modularize logging completely with fragile and
> > complicated aspects (100% AOP), b) use dummy methods and robust  
> > aspects
> > (part OOP and part AOP), and c) use a separate logging API 
> (100% OOP).
> >
> > Now we have added a fourth option d) use statement annotations and  
> > robust
> > aspects (100% AOP).
> 
> OK, got it. You make the assumption that you only want to log a  
> certain irregular subset of join points, while you want to trace a  
> very regular complete set of join points. That wasn't clear 
> to me. To  
> me tracing can also be about irregular sets of methods.
> 
> Don't you reintroduce code tangling with your approach?
> 

I see it as a compromise ("engineering tradeoff" :).  Ideally, there would
be a fifth option e) modularize logging completely with robust aspects (100%
AOP).  However, some concerns (like logging, error handling, optimizations)
are best understood in the context of, or are tightly coupled with, the base
source code, and we need an AOP solution for this.  

Statement annotations, and annotations in general, solve this problem albiet
invasively, so scattering is a consequence.  Noninvasive solutions are
currently not feasible because they fail to quantify the needed join points,
the aspects are too fragile, or the aspects are incomprehensible.  Possible
solutions to the first problem include statement-level join points, more
powerful pointcut languages, semantic join points, and XPIs.  Possible
solutions to the second include better aspect visualizations and support for
automatic aspect refactoring (Gregor's idea).

> 
> Pascal
> 
> -- 
> Pascal Costanza, mailto:[email protected], http://p-cos.net
> Vrije Universiteit Brussel, Programming Technology Lab
> Pleinlaan 2, B-1050 Brussel, Belgium
> 
> 
> 
> 


__________________________________________________
AOSD Discuss mailing list    -    [email protected]
To unsubscribe go to http://aosd.net

Check out the AOSD.net Wiki: http://aosd.net/wiki