Doctoral Symposium

Room: Rock and RollDate: Oct 20, 2008Time: 8:30 - 17:00
ChairTodd Millstein
University of California, Los Angeles

The OOPSLA Doctoral Symposium provides useful guidance for the completion of the dissertation research and initiation of a research career. The symposium consists of a dinner, followed by a full-day workshop. The Symposium will provide an interactive forum for doctoral students in one of two phases in their doctoral progress, apprentices and proposers:

Apprentices are students who are just beginning their research, are not ready to actually make a research proposal, but are interested in learning about structuring research and getting some research ideas. Apprentices serve as observers during the symposium, attend the symposium dinner, and participate in critiquing and providing feedback to the proposers.

Proposers are students who have progressed far enough in their research to have an Idea Paper and a structured proposal. But they will not be defending their dissertation in the next 12 months, so have enough time to incorporate the advice and suggestions discussed in the symposium.

Doctoral Symposium

Designing a Prosthetic Memory to Support Software Developers

Uri Dekel
Carnegie Mellon University


Developers rely on knowledge of their activities and project artifacts to remain oriented and avoid omissions and errors, but existing documentation practices are costly, offer limited traceability, and fail to draw attention to relevant knowledge. We propose a memory aid revolving around lightweight subjective knowledge elements supplied by the developers. These will be interleaved with an automatically-gathered objective record of activities into a "transcript" offering orientation and decision traceability. They will also be "pushed" into contexts in which they may be relevant such as invoking methods, increasing the prospects of knowledge use. The latter technique is also applicable to improving the usefulness of existing documentation.

Plug-in Architecture and Design Guidelines for Customizable Enterprise Applications

Reinhard Wolfinger
Johannes Kepler University Linz


Customizability and extensibility are important goals for enterprise application software. Complex enterprise applications should be made customizable to the needs of individual users, in order to simplify and streamline them. Enterprise applications should also be extensible, since it is impossible to fully meet customer requirements with a standard product. End users and third parties should be able to safely contribute any functionality the manufacturer did not already provide in the base product. We present an approach where we adopt the plug-in idea to the enterprise domain in order to improve customizability and extensibility. We designed and implemented a new plug-in platform that enables developers to build highly flexible applications, by breaking it up into a thin core application that can be extended with features that are plugged into the core and integrate seamlessly with it. Using run-time system adaptation mechanisms an application cannot only be customized to the needs of individual users, but can also be reconfigured for a specific working context without restarting it. The platform addresses specific requirements from the enterprise domain, such as secure and fault tolerant integration of third-party extensions. Designing customizable and extensible applications that are adaptable at run time brings up specific design issues. We will create design guidelines and best practice patterns, in order to provide guidance for software architects building plug-in-based applications. Finally, the platform and design guidelines will be validated by an industrial case study and a comparison study conducted with software engineering students.

Prototyping Domain-Specific Language Semantics

Daniel A. Sadilek
Humboldt-Universität zu Berlin


Domain-specific languages (DSLs) need semantics. I consider external DSLs with execution semantics in the modelware technological space. In my dissertation, I develop a framework called EPromise for prototyping execution semantics of DSLs. EPromise allows both operational and translational semantics descriptions. Operational semantics can be described with multiple languages: QVT, Java, Prolog, Abstract State Machines, and Scheme. DSL program interpretation can be animated and debugged. If Scheme is used to describe operational semantics, DSL programs can also be compiled for a target platform. Equivalence of operational semantics described with different languages could be tested by comparing execution traces. For a translational description, Scheme is used both for describing the translation and as the target language. Such a description allows to discrete-event simulate multiple instances of DSL programs and to compile DSL programs for a target platform. EPromise supports the transition from an operational description to a translational description within one framework.

Arbitrary Non-Contiguous Pieces of Computation: a New Join Point Model for Aspect-Oriented Programming

Hossein Sadat-Mohtasham
University of Alberta


Dynamic join point models define join points as the meaningful points in program execution. Pointcuts select a set of join points of interest, each of which is selected and advised individually and independently. That is, the relationships between join points are not taken into account in join point selection and advice. We suggest a provisional modularization mechanism that takes join point interrelationships into account to allow expressing natural cross-cutting concerns that are dependent on these interrelationships.

Improving Developers' Confidence in Test Results of Multi-threaded Systems: Avoiding Early and Late Assertions

Ayla Dantas
Universidade Federal de Campina Grande (UFCG)


Testing multi-threaded systems is challenging, specially due to their inherent non-determinism. As a result, considering the same test, we can have success and failure results for different test executions. This may happen due to bugs that are only revealed on certain thread interleavings, and which are difficult to reproduce. However, this may also be caused by a problem with the test. When the latter case happens, developers may waste a lot of time searching a bug that does not exist, or they may lose trust in the test, maybe not investigating real bugs. With this work, we want to support tests development through an approach to avoid test failures caused by a common problem with multi-threaded systems testing: assertions performed too early or too late. The approach's basic idea is to use thread monitoring and other techniques to avoid such problems during the development of tests and hence increase the developers' confidence in test results.

Checking Framework Interactions with Relationships

Ciera Jaspan
Carnegie Mellon University


Thesis statement: Many constraints between object oriented frameworks and plugins can be defined by specifications that describe how multiple objects relate and change their relationships over time. A tool can statically check a plugin's conformance to these specifications in a cost-effective manner and can add benefit or even replace custom tools for plugin development.

Validating Temporal Properties of Interacting Objects

Nomair A. Naeem
University of Waterloo


Many programming errors can be detected by checking whether objects in the program execute undesirable sequence of events. For a single object, these temporal properties can be expressed using typestate. However, defining temporal specifications only for a single object is too restrictive as an object is not isolated; it interacts with other objects. Some newer formalisms can express temporal properties of multiple objects but are mainly intended for dynamic checking. In our research, we are interested in extending techniques from static typestate verification to static verification of multi-object temporal specifications. Analyzing such specifications has two classes of applications: sound static verification and reducing runtime overhead compared to a purely dynamic checker.

The key difference between previous typestate analyses and our work is that typestate verification associates a single object to a temporal specification whereas we deal with groups of objects. Previously, we presented a static analysis which used two separate abstractions: a storeless heap abstraction modeling individual objects and an abstraction modeling the state for a group of related objects. While typestate analyses have typically used the storeless heap abstraction the abstraction for groups of related objects is novel. The analysis computes context-sensitive interprocedural information, flow-sensitively tracks individual objects along control-flow paths and uses the heap abstraction to update the state of groups of related objects.

Our previous work lays the foundation of a powerful static analysis for multi-object temporal properties but there are certain improvements that still ought to be made. We need to investigate additional temporal specifications and test the applicability of our analysis on these. Also, previous experiments have shown that we could further improve the analysis precision e.g. by including field and pointer information. Moreover, since the analysis computes context-sensitive interprocedural information it is heavyweight and we are looking into means of improving its efficiency.

Verifying Correct Usage of Atomic Blocks Using Access Permissions

Nels E Beckman
Carnegie Mellon University


While transactional memory's atomic block promises to greatly simplify the development of concurrent, thread-shared applications, it does not eliminate the difficulties associated with race conditions. The goal of this thesis is to show that access permissions, which statically describe the aliasing behavior of program references in object-oriented programs, provide a good basis for the verification of object protocols in concurrent systems, and can help prove that atomic blocks are being used correctly.