Wednesday, 29 October

15:00-15:45

Thursday, 30 October

12:00-12:45

In the first part of this demonstration, we will use visualization
techniques to show how Eclipse utilizes plugins and its extension
mechanism to form a basic runtime infrastructure that allows the
design and implementation of IDEs and general applications. We will
show how bytecode manipulation techniques can be used to instrument
all the classes in all the Eclipse jars and what possible
visualizations can be the result. We will start with a
bird's eye view and gradually dive down into the gory
details. The goal of this exercise is to gain a better understanding
of the inner workings of Eclipse and to address bugs and performance
issues of given plugins.

In the second part of the demo, we will investigate aspect-oriented
programming using AspectJ. We will show how one can combine the world
of Eclipse plugins and AspectJ. One such example would be a logging
aspect, implemented as a plugin. Using aspect techniques on Eclipse
plugin jars, would allow for the development of aspects that
modularize crosscutting concerns across plugin boundaries. We will
present an enhanced version of the Eclipse Core Runtime Platform that
integrates load-time weaving functionality of the AspectJ language
into the platform.

Attendees of this demonstration will see the running systems and how
they can be used. The implementation details of both the visualization
techniques used in part 1 and the enhanced Eclipse Core Runtime
discussed in part 2 will be described in detail.