Eric Bodden

14°C

To appear at the 2010 FSE/SDP Workshop on the Future of Software Engineering Research (FOSER). Download the paper here.

Abstract: Today’s Integrated Development Environments (IDEs) only integrate the tools and knowledge of a single user and workstation. This neglects the fact that the way in which we develop and maintain a piece of software and interact with our IDE provides a rich source of information that can help ourselves and other programmers to avoid mistakes in the future, or improve productivity otherwise. We argue that, in the near future, IDEs will undergo a revolution that will significantly change the way in which we develop and maintain software, through integration of collective intelligence, the knowledge of the masses. We describe the concept of an IDE based on collective intelligence and discuss three example instantiations of such IDEs.

Our 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.

The program for RV 2010 is now available.

I recently had the pleasure to host a PC Meeting conference call with skype, with 22 people! Actually things went surprisingly well. However, it really helps if people stick to a few rules. I have written down a few tricks that I learned on the way.

As many of you may know, JDK 7 will bring support for a new bytecode called invokedynamic. Thanks to Matthias Perner, a bright student of ours, Soot is already ready for this new bytecode today. I have just committed appropriate changes to the SVN trunk. The new instructions are handled as follows:

• On the Jimple, Grimp and Baf level, invokedynamic instructions appear as DynamicInvokeExpr with a static SootMethodRef that has class java.dyn.InvokeDynamic as target class. This is in accordance with the internal handling in JDK 7.
• SootMethodRefs which have java.dyn.InvokeDynamic as target class may not be resolved: calling resolve() will throw an exception
• On the Jasmin level, invokedynamic instruction appear in the form “invokedynamic <methodName>(<methodParams>)<methodRetType>“. In particular, there is no target class given.
• Jasmin translates this into an invokedynamic instruction with two arguments:
  • a NameAndType attribute referring to <methodName>(<methodParams>)<methodRetType> and
  • the constant “0″ (two zero bytes, i.e., a short); according to the VM spec this is reserved for future use.

The above is an experimental design. Comments are welcome! In the near future we plan to extend TamiFlex to handle invokedynamic as well.

In my publications section you can now find our RV 2010 paper on the Clara Framework. This is by far the most concise introduction to Clara; therefore I hope that people will find it more accessible than my thesis. download the paper here

Abstract: Researchers have developed a number of runtime verification tools that generate runtime monitors in the form of AspectJ aspects. In this work, we present Clara, a novel framework to statically optimize such monitoring aspects with respect to a given program under test. Clara uses a sequence of increasingly precise static analyses to automatically convert a monitoring aspect into a residual runtime monitor. The residual monitor only watches events triggered by program locations that the analyses failed to prove safe at compile time. In two-thirds of the cases in our experiments, the static analysis succeeds on all locations, proving that the program fulfills the stated properties, and completely obviating the need for runtime monitoring. In the remaining cases, the residual runtime monitor is usually much more efficient than a full monitor, yet still captures all property violations at runtime.

Quite a while back, Malte Clasen, Joachim Kneis and I wrote a seminar paper on Arithmetic Coding. Apparently it’s not a bad paper, as it has been heavily cited. In particular, people appear to appreciate Malte’s C++ implementation of Arithmetic Coding, which fits on a couple of pages. This week, Sina Momken emailed me a very nice re-implementation of the coder in C#. The implementation is available in source from our AC website. Thanks Sina!