****************************** Referee 1 *********************


The authors propose a Java class library for advanced 
concurrency control similar to that found in transactional 
databases. A new primitive is proposed, and both programming
and efficiency arguments are made as to its merits.
The paper is well written, although at times the discussion
is at a textbook level. I would encourage the authors to
reduce the content in sections 2 and 4 considerably.
Further, it might be useful to point out existing pragmatic
solutions to the problems they highlight. For example, the
banking example in Section 2 is easily solved in practice
by imposing an ordering based on, say, the account number.
Similarly, binary semaphores can be easily used to circumvent
the limitations of the "synchronized" statement. Conversely,
interesting issues such as the point about maintaining
fine-grained concurrency in in-memory data structures (sec 4)
should be expanded further. The rigor in sections 4 and 5
is commendable and adds significant strength to the paper.
Although impressed by its technical soundness, I am a little 
bothered by the implementation approach, in particular the
use of proxy objects that can obfuscate code, and be
counterproductive to the goals of "reducing the burden on 
the developer". It would be instructive to expand on
the potential programming pitfalls, e.g. similar to the
mention of exception handling contexts, and to make a stronger
case for language modification in 5.5. Section 6 is
very good and adds significant weight to the paper. Nevertheless,
I am uncomfortable with recommending acceptance in its
present form; my primary reservation is my suspicion
that all that is described in the paper can be accomplished
via semaphores. If this issue, and the other minor details
mentioned above can be satisfactorily addressed, I believe
this work would make a substantial impact and contribution.


****************************** Referee 2 *********************

The paper presents a framework for supporting Atomic Blocks in Java
with greater transparency. It proposes various mechanisms for
congruency control and suggested approaches with detailed evaluation
through simulation. However, there is no/much information about the
simulator used in the experiment, I advise authors to include a
citation to the simulator used in the experiment since I believe this
can helps readers to experiment with the code if they are interested.
Since you have JCF implemented framework and proposed how it can be
implemented in Java, why not try to implemente it in one of the
available open source Java compilers.

It will be wonderful if you can also implement a toy concurrent 
application with your JCF to manage atomic blocks and report 
results of experience.