Doctoral Symposium

Event Format

This is a full-day event of interactive presentations. Morning and early afternoon will be dedicated to the Doctoral Symposium, with late afternoon dedicated to the PhD Student Workshop. Besides the formal presentations, there will be plenty of opportunities for informal interactions during lunch and (possibly) dinner. It is planned that, like in 2010, members of the academic panel will give short presentations on a variety of topics related to doing research.

Each student will be given 10 minutes for the presentation. This will be followed by a 20 minutes discussion.

The student's advisor should send email to ecoop11-ds@comp.lancs.ac.uk no later than 18 July, 2011 and confirm that the advisor attended at least one of the student's presentation rehearsals.

Program

Monday, 25th July

Doctoral Symposium

9:00 - 9:30 Welcome, Introductions
9:30 - 10:00 A Framework for Collaboratively Editing Domain Specific Models
Amanuel Koshima
10:00 - 10:30 Sources of Memory Bloat Detection in Large-Scale Object-Oriented Applications
Adriana E. Chis
10:30 - 11:00 Coffee break
11:00 - 11:20 Inspirational talk
11:20 - 11:50 Making program refactoring safer
Gustavo Soares
11:50 - 12:20 Dynamic or Static - Bridging the Gap Between Assurance and Rapid Development
Gregor Richards
12:30 - 14:00 Lunch break
14:00 - 14:30 Object Focused Environments as Vehicles for Object-Oriented Modeling
Fernando Olivero

PhD Student Workshop

14:30 - 15:00 Diagnosing the Causes of Bugs from Bug Reports
Steven Davies
15:00 - 15:20 Inspirational talk
15:30 - 16:00 Coffee break
16:00 - 16:30 Application Optimization when Using Gradual Typing
Esteban Allende
16:30 - 17:00 Thread-safe Efficient Mutable Arguments for Remote Method Invocation in Java
Paolo G. Giarrusso

Planning for Next Year's Workshop

17:00 - 17:30 Conclusion. Planning for next year.
17:30 Finish.

 

Academic Panel

  • Dave Clarke, Katholieke Universiteit Leuven, Belgium
  • Robert L. Bocchino Jr., Carnegie Mellon University, USA
  • Alessandro Warth, Viewpoints Research Institute, USA
  • Shahar Maoz, RWTH Aachen University, Germany

  

Accepted Papers

A Framework for Collaboratively Editing Domain Specific Models
Amanuel Koshima

Modeling process most of the time demands collaboration among a number of engineers so that DSML tools need to be support collaboration. In this work, we will present DiCoMEF that will be developed to support collaborative modeling.

Sources of Memory Bloat Detection in Large-Scale Object-Oriented Applications
Adriana E. Chis

Large-scale enterprise applications are complex. Usually they are built by deeply layering frameworks and components. Often these applications suffer from excessive memory bloat (i.e. inefficient usage of memory). The complexity of these applications proves to be a high barrier in finding whether large memory consumption is due to memory bloat, and more importantly, what is the root cause if a problem occurs. This research aims to advance memory analysis by developing techniques and tools that automatically detect frequently occurring patterns of memory bloat, infer the root cause of a memory issue, and help in removing patterns of memory bloat either automatically through program transformation, or by suggesting possible solutions.

Making program refactoring safer
Gustavo Soares

Each refactoring implementation must check a number of conditions to guarantee behavior preservation. However, specifying and checking them are difficult. Therefore, refactoring tool developers may define too weak conditions, which leads to non-behavior-preserving transformations, or too strong conditions preventing behavior-preserving transformations. We propose an approach for improving the developer's confidence that the refactoring was correctly applied, and a technique to test refactoring implementations with respect to weak and strong conditions.

Dynamic or Static - Bridging the Gap Between Assurance and Rapid Development
Gregor Richards

Although it is a simplistic and imprecise classification, programming languages are often considered to be either "dynamic" or "static". Dynamic languages allow quick prototyping and are considered to be well-suited for small or once-off tasks, but provide little assurance and are often fairly slow. Static languages are better-suited to common software engineering practices, provide static guarantees and are generally faster, but are restrictive and force programmers to comply to their paradigm. Since dynamic languages are thought to be better suited for fast development, and static languages for long-time maintenance, dynamic languages are sometimes characterized as prototyping languages, under the theory that software prototypes will be developed in them, then translated into another language. However, translating software is both time consuming and error prone, and it's unclear how often this process is successful. Various techniques have been introduced to bridge the gap between dynamic and static languages, usually focusing on the disparity in typing guarantees. These include introducing a dyn (dynamic) type to a static type system, introducing static subsets to dynamically-typed languages, generalized type inference, gradual typing, contracts, pluggable type systems and hybrid type checking. Although these systems all provide a middle ground, they also have disadvantages. But more fundamentally, they are all made with idealistic assumptions about the behavior of dynamic code; namely, that code written in these dynamic languages does not need the dynamic features the language provides, and in fact the behavior is quite predictable (e.g. values are always of the same type, duck typing is not used). This assumption has remained mostly untested. Work has been done to measure this dynamic behavior with Python and other languages, but my work has focused on JavaScript, for the practical reasons that JavaScript is highly dynamic, and the source code for JavaScript applications in its most common environment (the web browser) is readily available.

Object Focused Environments as Vehicles for Object-Oriented Modeling
Fernando Olivero

Object-oriented programming (OOP) languages promote reasoning that revolves around objects that send each other messages to collaborate to solve a problem. To practically make this happen, developers write programs, aided by integrated development environments (IDEs). We claim that IDEs may be an impediment for programming, because they treat program elements as text, which may be counterproductive for manipulating dynamic content such as a model of collaborating objects. In our work we investigate the usage of an alternative metaphor for building development environments for (pure) OOP languages. We settled on the object focused metaphor, which allows developers to write programs by creating and manipulating intuitive depictions of object-oriented constructs. We built a prototype called Gaucho, which embodies our ideas. We conducted a preliminary controlled experiment comparing Gaucho against a traditional IDE in the context of program comprehension. Our preliminary results suggest that alternative -visual- IDEs may be superior to traditional IDEs as programming vehicles, enabling us to question the traditional text-based interfaces.

Diagnosing the Causes of Bugs from Bug Reports
Steven Davies

Developers spend a large amount of their time diagnosing the causes of bugs. Often they do so based on information provided in a bug report, along with their own knowledge. A tool which could use the information in a bug report to recommend the location of a particular bug could help reduce the time spent on diagnosing the cause. A number of research areas related to the relationships between bug reports and the bug's location in the code are identified, as a precursor to producing such a tool. A summary of a manual analysis of the causes of 166 bugs in two open-source projects is given, along with an evaluation of two techniques to automatically identify the causes of a bug from the changes applied to fix them.

Application Optimization when Using Gradual Typing
Esteban Allende

Static and dynamic typing have different strengths and weaknesses. Gradual typing allows a programmer to combine statically and dynamically typed sections of code in one program. This allows the best typing choice for each part of the code. Sadly, the advantages of efficient program execution due to static typing do not yet carry over to a gradual typing system. This is because no optimizations have yet been proposed that take advantage of the type information present in this context. In this work, we propose optimizations for gradually typed applications, focused on three areas: optimizing method lookup, optimizing type checking and breaking encapsulation. We also propose how we are going to validate these optimizations.

Thread-safe Efficient Mutable Arguments for Remote Method Invocation in Java
Paolo G. Giarrusso

Distributed object-oriented middlewares, like Java RMI or CORBA, abstract message sends into method calls, providing programmers with a familiar object-oriented programming model. However, a remote method cannot mutate the heap of the client with the same ease as a local method without incurring significant overhead. Workarounding this limitation requires exposing implementation details of the server, thus compromising modularity. Existing solutions for Java do not implement the full Java semantics, in particular for multi-threaded programs. Alternatively, they require using non-standard JVMs, a requirement which compromises portability and interoperability. We discuss a simple approach to eliminate the semantic difference, characterize its overhead and discuss novel optimizations tailored to our scenario, which we believe will minimize the overhead.
 

Committee

  • Andreas Mertgen, Technischen Universitat, Berlin, Germany
  • Stephen Nelson, Victoria University of Wellington, New Zealand
  • Hesam Samimi (chair), University of California, Los Angeles, USA
  • Lucas Satabin, Technische Universitat, Darmstadt, Germany

Previous Experiences

The ECOOP Doctoral Symposium is an excellent place to meet many interesting people and discuss new ideas related to your research topic. It has a friendly atmosphere which makes everybody welcomed and relaxed. By attending the PhD symposium last year, I had the opportunity to engage in new collaborations with researchers from different institutions. I also received feedback from both well-established researchers and fellow PhD students which had a great positive effect on my thesis. I would certainly recommend all PhD students to attend the ECOOP PhD Symposium and Workshop.

Eduardo Figueiredo, participant DS ECOOP'08

The ECOOP Doctoral Symposium was a remarkable event. It was an honor to get feedback on my personal thesis topic from such well-established researchers in the field. Their comments not only encouraged me to continue with my thesis work but also gave me valuable feedback on how to refine my concrete topic and bring the overall topic into shape. In addition, I found the other students' talks to be some of the most interesting ones at ECOOP. Some of them were very inspiring even for my own work. Overall, my participation in the symposium will certainly have a great positive effect on my thesis. Apart from that it was a fun day which made me meet many interesting people.

Eric Bodden, participant DS ECOOP'07

 

Contact

For additional information about Doctoral Symposium, please contact the ECOOP 2011 Doctoral Symposium Chairs at ecoop11-ds@comp.lancs.ac.uk.