Automated Software Engineering

Eric | February 19, 2010

In the upcoming summer semester, Martin Monperrus and I will be teaching a new course on Automated Software Engineering, here at TU Darmstadt. During the course we will look at the entire development life-cycle from a tool perspective: How can automated tools support programmers during the design, implementation, testing and maintenance of a software product? We will talk about approaches to…

  • automated analysis & definition of requirements
  • computer-aided design of software
  • implementation with intelligent IDEs
  • automated testing and verification
  • computer-aided bug finding
  • aiding program understanding by mining latent specifications from existing software
  • advanced debugging & profiling techniques
  • computer-aided refactoring and documentation

The course webpage contains a rough outline of the topics that we have planned but at this point we are still open for suggestions, as long as they fit the general topic.

Comments
Comments Off on Automated Software Engineering
Categories
Research
Tags
Bug finding, Software Engineering, Teaching, Testing, Tools

New publication: Finding Programming Errors Earlier by Evaluating Runtime Monitors Ahead-of-Time

Eric | July 31, 2008

image I am happy to announce the final version of our new FSE paper (joint work with Patrick Lam and my supervisor Laurie Hendren). You can grab the paper here. The idea of the paper is that runtime monitoring is nice because it manages to show you only actual errors, but nevertheless one should make a best effort to evaluate a runtime monitor ahead-of-time, i.e. at compile-time, as well as possible, so that programmers can find errors in the programs earlier in the development process.

Read the rest of this entry »

Comments
Comments Off on New publication: Finding Programming Errors Earlier by Evaluating Runtime Monitors Ahead-of-Time
Categories
Research
Tags
Bug finding, Object representatives, Runtime Monitoring, Runtime verification, Static Analysis, tracematches

Off to Seattle

Eric | July 17, 2008

image

I’ll be off to Seattle for the next week, presenting at Microsoft and attending ISSTA to present my paper on Racer. From what I’ve heard, Seattle is supposed to be quite beautiful, especially around this time of the year. I’ll tell you next week, so stay tuned 😉

Comments
Comments Off on Off to Seattle
Categories
Misc, Research
Tags
Bug finding, ISSTA, Microsoft, Race detection, Racer, RacerAJ, Seattle

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

Data races in the JDK!

Eric | June 14, 2008

At the moment I am doing some more work on evaluating tracematches ahead-of-time. One tracematch patten that we use in our benchmarks we called ASyncIter, a simplified version of which looks as follows:

tracematch(Collection c) {
	sym sync after returning:
		call(* Collections.synchr*(..)) && args(c);
	sym iter before:
		call(* Collection.iterator()) && target(c);

	sync iter {
		if(!Thread.holdsLock(c))
			error(``Have to synchronize iterator at ''+thisJoinPoint);
        }
}

This tracematch reports an error if you create a synchronized collection and then iterate over this collection without holding a lock on the collection object. According to the JDK javadoc this is forbidden as it can lead to a race condition. One has to use synchronized collections as follows:

Read the rest of this entry »

Comments
Comments Off on Data races in the JDK!
Categories
Research
Tags
Bug finding, Java, PLDI, Race detection, RaceFuzzer, Sun

False positives and negatives of the Racer algorithm

Eric | June 11, 2008

Today I gave a presentation about Racer in our lab seminar and people asked me some really interesting questions. I thought the answers might interest other people too so I would post them here…

Can Racer produce false positives?

Yes, Racer can produce false positives but out of our 70 reported races only two were false positives. There are two primary reasons for false positives. First reason (quoting from the paper):

Read the rest of this entry »

Comments
Comments Off on False positives and negatives of the Racer algorithm
Categories
Research
Tags
Bug finding, Java, Race detection

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

Proposal slides online

Eric | December 12, 2007

image Hey, I just passed my Ph.D. proposal exam today! I decided to upload my slides, because apparently people enjoyed them a lot. You can get them from here.

Presentation Zen has a long list of good tips of how to design beautiful slides.

Comments
Comments Off on Proposal slides online
Categories
Research
Tags
Bug finding

New TR: Static Analysis Techniques for Evaluating Runtime Monitoring Properties Ahead-of-Time

Eric | November 23, 2007

imageToday I am proud to present our brand new Technical Report in which Patrick Lam, Laurie Hendren and me present how you can use static analysis to evaluate runtime monitoring properties ahead-of-time, i.e. at compile time opposed to at runtime.

We have been working on this topic for about a year now, with different approaches and it actually took us until some weeks ago to get it actually all worked out. The coolest thing is that the approach we found in the end is really surprisingly simple, yet very effective. All it needs is a good static abstraction and super-precise pointer analysis. That’s it. The problem that we had before was that we were tying to make things more complicated than they were.

Read the rest of this entry »

Comments
Comments Off on New TR: Static Analysis Techniques for Evaluating Runtime Monitoring Properties Ahead-of-Time
Categories
Research
Tags
Bug finding, Java, Programming

How relational aspects could have helped Princeton win the DARPA challenge

Eric | November 18, 2007

image Bryan Cattle recently explained why their autonomous car developed for the DARPA urban challenge did not make it: They simply had a memory leak in their C# code, filling up their entire heap space after about 28 minutes which made the computer crash. It’s important to note that this is not at all any flaw in C#. As C# is now, it was the programmers’ fault: In their code they kept around a list of obstacles which the car passed by. Obstacles that came out of sight were deleted… but not quite. Because the obstacles were registered as event listeners somewhere else in the code they were reachable and hence could not be garbage collected. Too bad, but how could such a problem have been avoided?

Read the rest of this entry »

Comments
Comments Off on How relational aspects could have helped Princeton win the DARPA challenge
Categories
Research
Tags
Bug finding, Coding, DARPA challenge, Java