PROSE (PROgrammable extenSions of sErvices)
Open Source Project

Adaptability to the dynamic nature of the
computing environments is one of the biggest challenges for software
engineering and has become an important feature in today’s modern
systems, mobile and pervasive computing. Applications which execute in
such environments need to adapt to
changing settings they encounter during their active life time. They
should be able to react and modify their behavior dynamically in
response to changes in their execution environments, without being
required to be preprogrammed with the software functionality needed for
typical adaptations.

Our research work addresses this challenge. PROSE is an
infrastructure that supports dynamic adaptation of applications by
extending their functionality with new code (extensions) used to
enhance, modify, or control the functionality already present in the
application. The system performs controlled,
systematic,
and efficient modification of
the code of running Java applications without requiring them to be shut
down. Changes are
composable, and may be reordered or selectively withdrawn at any time.
The modifications are expressed as Java classes, providing additional
development benefits.

Given the possibility to add and remove new
functionality at an arbitrary point in time, it is important to know at
any time what extensions are currently inserted into an application and
what execution points they denote. For this purpose, PROSE provides powerful tools that allow the users
to see how a given extension will affect the application behavior at runtime. Embedded into an Eclipse
plug-in, the PROSE
Development Tools for Eclipse allows runtime monitoring and
adaptation of applications from Eclipse. The tools allow to monitor and
modify
the code of local and remote applications at runtime.

PROSE can be used for a wide range of
purposes: program instrumentation and profiling, online debugging and
logging, hotfixes and security patches, evolution of critical legacy
applications, software adaptation in a number of applications including
web servers, J2EE containers, and mobile computing. Furthermore, PROSE
provides the infrastructure for a number of research projects exploring
the use of PROSE for assuring application performance, enterprise
applications, software evolution, and implementation of service
migration.

People

Contact information

About the PROSE project

PROSE was one
of the first platforms that tackled the problem of dynamic AOP. As a
result, PROSE has evolved through a number of versions, each one of
them based on different forms of interception and weaving.

The first
version of PROSE used the Java
Virtual Machine Debugger Interface
(JVMDI)event notification
mechanism to convert join-points into stop
points. Once the application had been stopped, the advice was executed
externally to the application although the advice had access to the
context where it was being executed (e.g., stack frames, calling
parameters for methods, etc.).

The second
version of PROSE extended this model by giving the option of,
instead of using the debugger, using the baseline JIT compiler. The idea was
to weave hooks
into the application at native code locations
that correspond to all
potential join-points. When executed, the hooks determine whether an
advice needed to be invoked for that particular join-point and called
the advice.

The new
version of PROSE uses (a) an advice
weaving strategy for method replacement join-points and (b) a stub weaving mechanism for
join-points involving external advices. It implements adaptation by a
novel
mechanism based on dynamic bytecode instrumentation
that supports method code replacement while
an application is running.
Modifications take the form of replacement method
bodies, and can use both type-based and regular expression patterns to
select code for replacement. New code can make use of replaced method
implementations cleanly, facilitating code evolution. Changes are
composable, and may be reordered or selectively withdrawn at any time.
Integrated into an Eclipse plug-in,
the PROSE
Development Tools for Eclipse is used to develop and run
applications inside Eclipse, as well as for standalone Java
applications. It provides tools for creating, runtime monitoring and
distributed visualization of remote extensions.

An important
characteristic of PROSE is that these different weaving mechanisms are
meant as alternatives. The idea is to mirror the flexibility offered by
middleware platforms in which designers can choose different approaches
depending on the type of application involved.

Download

PROSE is an Open Source project and can be downloaded from SourceForge.

Documentation

Documentation about PROSE: system
architecture, design, implementation, performance evaluation,
programming runtime extensions, tools, PROSE Development Tools for
Eclipse, and
applications of PROSE can be found here.

Getting started with PROSE => PROSE
User Manual. Note:
A new version of the User Manual will be available soon on the project
website.

Additional
work has been done by Stephan Heinzer, Marius Buerki and
Philipp Sieber. They worked on semester projects
for integrating Lego Mindstorms with Java, and monitorisation and
logging of
controlled devices (based on Lego).