[abc] abc CC paper :-(

Details of the PC's Decision
Detailed Comments from PC Chair

Dear author,

The CC'05 program committee recently met to decide on the technical
program of the conference.

I regret to inform you that your paper has not been selected for
presentation at the conference. The competition was tough this year:
We have received 90 quality submissions but were able to accept only
21 papers.

I hope to see you at CC in Edinburgh.

Regards,

Ras Bodik
CC'05 Chair

Single Reports by PC Members
Report 071-R1
Score 5
Confidence 3
Detailed Comments

Summary paragraph
        The paper presents the abc compiler, a Java source/bytecode
        to bytecode compiler that handles static and dynamic aspects.
        The tool is built using Polyglot (a semantic checker and AST
        generator for Java) and Soot (a Java bytecode analyzer).
        abc takes source and aspects and produces Java bytecode
        files. These files implement static aspects: declare
        warning/error, declare parents, and declare intertypes,
        and dynamic aspects: before, after, and around advice.

points for
        topical/timely research
        availability as well as modularity of implementation
        well written/described experience paper
points against
        incremental - such compilers do exist (experience paper)
        implementation is specific to the authors' compilation
                infrastructure (not general)
        nothing particularly novel about the compiler extensions
                needed to enable the use of aspects
                - perhaps this would be a better submission as a tool paper

specific comments

        Define the term pointcut (and other such aspect-specific vocabulary)
        where it is first used.
        
        I would have liked to have seen a better motivation for
        the use of aspects at all as part of the introduction.

        I would have liked to see more discussion about the analysis and
        reweaving techniques mentioned in Section 4.4.
        
        What is the performance impact on compilation time
        for including aspects (how much more work is being
        performed)?

 
Report 071-R2
Score 5
Confidence 3
Detailed Comments

This paper describes a compiler for AspectJ. Clearly, a lot of
effort and work has gone into the compiler. However, there is
not much in terms of conceptual or deep contribution in this
paper. It is mostly an experience report.

The paper covers many aspects of the compiler. However, this itself
is also a drawback of the paper. It is somewhat hard for a reader to
extract/distill lessons from this experience that they can take away
and use in a different context.

Though not very compelling (due to the above reasons), the paper does
present an useful overview of a compiler for aspect-oriented languages.

 
Report 071-R3
Score 4
Confidence 3
Detailed Comments

This paper presents the design and implementation of the abc AspectJ compiler.
This compiler is built upon two building blocks, namely Polyglot and Soot. The
former tool is an extensible compiler framework for Java; the latter tool is a
framework for analyzing and transforming Java programs. The paper first gives a
nice introduction to AOP. Polyglot and Soot are then briefly described. The
architecture of abc is presented, as well as the way it fits with the building
blocks. The implementation of AspectJ features in this architecture is discussed.

The work is very well presented. The architecture of the compiler, as well as its
components are clearly explained and motivated. I agree with the authors that this
paper is a great educational value. However, it is not really a new research
result. Building a compiler for aspects has been done before; besides some
qualitative/subjective criteria, the reader has no way of assessing the progress
made by this compiler compared to others. The authors' compiler may be better
designed and implemented than existing ones, yet, this is not enough to make it a
research contribution. Specifically, there needs to be some comparative study,
maybe some measurements. These studies may need to be invented in the context of
AOP compiler, or maybe existing strategies can be used. For example, why didn't
the authors compared their compiler to the ajc compiler, as far as the compilation
time and execution time of woven code. If that makes sense, why wasn't it done. If
that doesn't make sense, why isn't it discuss, as well as possible other
strategies to compare AOP compilers.

Legend
Score Description
0 Out of scope
1 Strongly negative (and will argue against)
2 Negative (and will argue against)
3 Somewhat negative (but won't argue against)
4 Neutral
5 Somewhat positive (but won't argue for)
7 Strongly positive (and will argue for)
8 --
9 --

Referee's Confidence Description
1 Low
2 Medium
3 High
Received on Sat Dec 11 13:31:41 2004