Theo and Pengcheng were also there. Please present your views.

Robbie Findler, Jonathan Aldrich and Gregor Kiczales were the panelists on
the panel on modularity and aspects.

Robbie showed many examples where equivalences between program fragments
no longer hold in the presence of aspects.

Jonathan, who has an ECOOP 2005 paper on this topic, debunked obliviousness.
He wants the base program to export pointcuts but under the control
of the aspect writer. If there is a change to the base,
we need to verify that all those exported pointcuts are still correct
in the context of the aspects that use them.

Gregor presented the ideas behind the paper with Mira that says that
interfaces only become complete at integration time. (I am not sure whether
I say this right). Gregor made the important point that aspects
provide a programmatic solution to a problem that when solved 
manually leads to worse problems. With aspects you define a crosscutting
interface and then you program against it. This crosscutting interface
reaches into the "internals" but that is ok.

The same issues are in AP. See the OOPSLA paper with Mira in 1998.
And also:
http://www.ccs.neu.edu/research/demeter/papers/boaz-jacm/sound.html

An adaptive method is written against 
a participant graph interface that is mapped to a class graph.
When the class graph changes, we need to check how the mapping 
needs to be updated to make the adaptive method work again.
Maybe the change in the class graph is so big that we even need to
update the adaptive method. Traversals are used twice:
To express the adaptive method in terms of the participant graph and to
map the participant graph to a real application class graph.

We need something similar for AOP: The aspect is written against
an idealized interface call graph that serves as an interace between
aspect and concrete use. Then the interface call graph is mapped 
to a concrete call graph (base program).

When the base program changes, we need to verify whether the mapping
and aspect still work. The interface call graph shields us from 
having to update the aspect too often.

Pointcuts=traversals are used twice: 
To express the aspect against the interface call graph and to
map the interface call graph to a concrete call graph.

We need to work out a concrete example of
aspect / interface call graph / concrete call graph.

Who takes the lead? A first example woul be when we express
an adaptive visitor using AspectJ pointcuts:

pointcut visitingNode ...
pointcut crossingEdge ...

But we need a more traditional AspectJ example. Gregor's 7 decomposition
paper with Mira at ECOOP 2005 might contain a good case study.

-- Karl