Learn More
Traditional profilers identify where a program spends most of its resources. They do not provide information about why the program spends those resources or about how resource consumption <i>would change</i> for different program inputs. In this paper we introduce the idea of <i>algorithmic profiling</i>. While a traditional profiler determines a set of(More)
Many experimental performance evaluations depend on accurate measurements of the cost of executing a piece of code. Often these measurements are conducted using infrastructures to access hardware performance counters. Most modern processors provide such counters to count micro-architectural events such as retired instructions or clock cycles. These counters(More)
Interactive applications with graphical user interfaces are prevalent in today's environment: Everybody with access to any kind of computer constantly uses them. A significant body of prior work has devised approaches for automating the functional testing of such applications. However, no such work exists for automatically testing their <i>performance</i>.(More)
Learning to create well-designed and robust Java programs requires, besides a good understanding of the language, a significant amount of practice. In this paper we present the JavaFest, a collaborative learning technique for teaching Java to beginning programmers. A JavaFest is a group exercise that instructors can add to their repertoire of teaching(More)
We present an approach that partitions a software system into its algorithmically essential parts and the parts that manifest its design. Our approach is inspired by the notion of an algorithm and its asymptotic complexity. However, we do not propose a metric for measuring asymptotic complexity (efficiency). Instead, we use the one aspect of algorithms that(More)
When designers of Java runtime systems evaluate the performance of their systems for the purpose of running client-side Java applications, they normally use the Dacapo and SPEC JVM benchmark suites. However, when users of those Java runtime systems run client applications, they usually run interactive applications such as Eclipse or NetBeans.
We recently published a paper at ECOOP presenting a new software design metric, essence, that quantifies the amount of indirection in a software design. The reviews were overwhelmingly positive and included statements such as "The evaluation of the metric is fantastic." However, we also received feedback from senior researchers who do not believe that we(More)
Platforms such as Java provide many software engineering benefits. However, these benefits often come at the cost of significant runtime overhead. In this paper we study the potential for hiding some of that overhead by employing speculative execution techniques. In particular, we study the predictability of class-loading requests and the potential benefits(More)
  • 1