Well, that was some good links, but they're all pretty hand-wavy about
what AOP is, other than great.

Here's some quotes, maybe you can see why I'm not quite graspoing the
point yet.

Quoteing mlipper / US-ABP.com, on Thu, Feb 05, 2004 at 01:09:22AM +0900:
> Check out http://www.aspectJ.org . This is a Java-specific aspect-oriented
> framework that is (arguably, depending on who you ask) the most advanced in
> terms of functionality. Although the docs relate to this framework in
> particular, they provide a coherent intro to the subject. 

They seem to assume you already have an idea what AOP is:

  Many software developers are attracted to the idea of aspect-oriented
  programming (AOP) but unsure about how to begin using the
  technology. They recognize the concept of crosscutting concerns, and
  know that they have had problems with the implementation of such
  concerns in the past. But there are many questions about how to adopt
  AOP into the development process. Common questions include:        

    Can I use aspects in my existing code?

    ...

  (From the intro in the programming guide).

I'm still at the "what's an aspect" stage!

I read further, and now I wonder what a joint-point is, a pointcut, an
advice, and still don't have a clue what an aspect is...

Cross-cutting seems more straightforward, at least in the abstract.

> Also check out http://aspectwerkz.codehaus.org/ and

Their documentation starts with the very encouraging:

  You most likely not learn Aspect-Oriented Programming by only reading
  this paper. If you are a beginner I would recommend that you first
  read some introductory articles on the subject.                  

> http://nanning.codehaus.org/ .

And their doc's top-level link to AOP leads to:

  Aspect Oriented Programming

  Might not be the best name for what Nanning does. 

Hmmm... :-)
  
So, all I know so far is when you've got an issue (like user
validation), and you've got to put code dealing with it all over the
place, AOP should help.

You find all the places, those are called join-points, and somehow
aspect code appears there?

(and, what's an aspect, again?)

I'm particularly confused, because in OOP, this isn't such a big deal, I
don't think. You'd give objects a reference to a UserValidation object,
and they'd use it to do the validation, so, all that logic is central.
Hey, it can even be singleton, so they can just get if from the system.

There's lots of handwaving about how AOP allows you to factor more stuff
out than you can factor out with just OOP, etc, etc, but **how**.

It sounds cool, but I was looking for a simple example, like you'd use
to show a C programmer what an object was in C++... This is a Employee
class, it has a Salary, you can fire it, but different kinds of emplyees
(Developer, Ceo) get fired differently, so they are derived from
Employee and specialize the fire() method...

I am currently downloading the aspectj examples, maybe I'll see the
light.

Still displaying aspects of confusion,
Sam