FOAL Keynote: Towards Typesafe Weaving for Modular Reasoning in Aspect-Oriented Programs

Eric | January 20, 2012

Attending AOSD? Consider coming two days early to enjoy beautiful Postdam and attend FOAL. I will be giving a keynote presentation in which I will be talking about Closure Join Points and Join Point Interfaces (joint work with Milton Inostroza and Eric Tanter), and how they allow, for the first time, to define aspects that can be truly modularly type-checked and therefore are completely de-coupled from the base code they advise.

Abstract:

In previous work, we and others have studied how aspects can implement important cross-cutting concerns, such as runtime monitors, security monitors, and other security primitives. It is hard to design aspects that implement such concerns correctly. Therefore, once written, one desires to reuse the according aspect definitions for other systems.

In current aspect-oriented systems, however, aspects usually carry, through their pointcuts, explicit references to the base code. Those references are fragile and give up important software engineering properties such as modular reasoning and independent evolution of aspects and base code, hence hindering aspect reuse. A well-studied solution to this problem is to separate base code and aspects using an intermediate interface abstraction. Read the rest of this entry »

Comments
Comments Off on FOAL Keynote: Towards Typesafe Weaving for Modular Reasoning in Aspect-Oriented Programs
Categories
Research
Tags
AOP, AOSD, AspectJ, CJP, JPI

Closure Joinpoints: Block Joinpoints without Surprises

Eric | December 28, 2010

Closure JoinpointsTo appear at AOSD 2011:

Block joinpoints allow programmers to explicitly mark regions of base code as “to be advised”, thus avoiding the need to extract the block into a method just for the sake of creating a joinpoint. Block joinpoints appear simple to define and implement. After all, regular block statements in Java- like languages are constructs well-known to the programmer and have simple control-flow and data-flow semantics.

Our major insight is, however, that by exposing a block of code as a joinpoint, the code is no longer only called in its declaring static context but also from within aspect code. The block effectively becomes a closure, Read the rest of this entry »

Comments
Comments Off on Closure Joinpoints: Block Joinpoints without Surprises
Categories
Research
Tags
AOSD, AspectJ, Closures, Joinpoint

Aspect-oriented Race Detection in Java

Eric | September 3, 2010

TSE PaperOur paper on Aspect-oriented Race Detection in Java (joint work with Klaus Havelund from NASA JPL) is now available on the TSE website and here. It’s part of a TSE special issue on best papers from ISSTA 2008.

The paper enhances the approach presented at ISSTA to also take thread spawns and joins into account. This addresses an omission in the original algorithm raised by Bill Pugh during the ISSTA conference.

Abstract:

In the past researchers have developed specialized programs to aid programmers detecting concurrent programming errors such as deadlocks, livelocks, starvation and data races. In this work we propose a language extension to the aspect-oriented programming language AspectJ, in the form of three new pointcuts, lock(), unlock() and maybeShared(). These pointcuts allow programmers to monitor program events where locks are granted or handed back, and where values are accessed that may be shared amongst multiple Java threads. We decide thread-locality using a static thread-local-objects analysis developed by others. Using the three new primitive pointcuts, researchers can directly implement efficient monitoring algorithms to detect concurrent-programming errors online. As an example, we describe a new algorithm which we call RACER, an adaption of the well-known ERASER algorithm to the memory model of Java. We implemented the new pointcuts as an extension to the AspectBench Compiler, implemented the RACER algorithm using this language extension and then applied the algorithm to the NASA K9 Rover Executive and two smaller programs. Our experiments demonstrate that our implementation is effective in finding subtle data races. In the Rover Executive RACER finds 12 data races, with no false warnings. Only one of these races was previously known.

AOSD 2009

Eric | March 2, 2009

image This week I will be attending AOSD 2009, at Charlottesville, VA. (I hope it’s going to look at least close to what it looks like on this picture. Probably not, at this time of the year.) Anyway, I will be presenting my paper on Dependent Advice. I also plan to attend Alex Villazón’s demo on the MAJOR and CARAJillo tools, which allow you to (finally!) weave into the Java runtime library without having to worry about breaking it. In my session, there will also be some interesting talks about data-flow pointcuts and expressive scoping of distributed aspects (curious to find out what these are). Stay tuned for more…

Update: You can download my slides here… PPTX, PPT, PDF – enjoy!

Dependent advice: A general approach to optimizing history-based aspects

Eric | December 9, 2008

image I am happy to announce that my latest research paper has been accepted for publication at AOSD 2009. The paper is titled Dependent advice: A general approach to optimizing history-based aspects (paper here), and that’s really what it is about. If you know my past work, then you also know that my work is concerned with evaluating runtime monitors based on tracematches at compile time. The purpose of Dependent Advice (an extension to ordinary AspectJ advice) is to generalize this idea. With dependent advice, one can apply the same powerful whole-program optimizations to normal aspects that previously one could only apply to tracematches. Sounds exciting? So how does it work?

Read the rest of this entry »

Comments
Comments Off on Dependent advice: A general approach to optimizing history-based aspects
Categories
Research
Tags
AspectJ, Dependent Advice, LinkedIn

A monitoring solution to the data races in the JDK

Eric | June 16, 2008

A few days ago I blogged about a few really subtle data races that can easily be triggered in the JDK, when invoking methods like containsAll on synchronized (!) collections. In the following code you can get a race on sl2 because sl1.containsAll(sl2) synchronizes on sl1 only, not on the argument sl2!

List sl1 = Collections.synchronizedList(new ArrayList());
List sl2 = Collections.synchronizedList(new ArrayList());
sl1.containsAll(sl2);


Here are now two easy aspect-oriented solutions to this problem, first in form of a tracematch, then in form of a normal AspectJ aspect. You can download the tracematch here and the plain AspectJ aspect here.

Read the rest of this entry »

Comments
Comments Off on A monitoring solution to the data races in the JDK
Categories
Research
Tags
AspectJ, Bug finding, Data races, tracematches

Racer: Effective Race Detection Using AspectJ

Eric | May 7, 2008

image

I am happy to announce the availability of my latest publication (joint work with Klaus Havelund, to appear at ISSTA 2008). This time it’s about how to detect data races in multi-threaded Java programs using three novel pointcuts that we implemented as a language extension to AspectJ, and using a novel algorithm called Racer that makes use of these pointcuts. We applied our implementation to the NASA K9 Rover Excecutive and found 70 data races, only one of which was known to NASA developers, although extensive studies had been performed on the code, using all sorts of error detection tools, at a time where 68 of these races were already present!

Download the paper here, our extended Technical Report here, or continue reading here.

Comments
Comments Off on Racer: Effective Race Detection Using AspectJ
Categories
Research
Tags
AspectJ, Bug finding, Java, NASA, Race detection, Racer, Rover, Semantic pointcuts