Publication

Dynamic adaptation is one of the greatest challenges for software engineering and is increasingly important, as the computing environments continue to expand and diversify. 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. The research presented in this dissertation addresses this challenge. The first part of this dissertation presents PROSE, an infrastructure that supports dynamic adaptation by extending applications at runtime. The system performs reversible and systematic changes to running Java applications without requiring them to be shut down. 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. The modifications are expressed as Java classes, providing additional development benefits. We describe the architecture of PROSE, the challenges of using aggressive inlining to achieve high performance, and use standard benchmarks to demonstrate code performance comparable with, or better than, compile time systems from the Aspect-Oriented Programming community. There is a growing number of applications which need to run continuously for a long period of time and have long-lived objects which need to be made persistent. The second part of this dissertation presents the application of PROSE in the implementation of dynamic persistence. That is persistence becomes not only an orthogonal concern but one that can be added to an application at runtime without interrupting its operations. With dynamic persistence we make the application independent of the container, so it can move from container to container and be made persistent at runtime without having to stop or redeploy the code. Our approach is a dynamic infrastructure based on PROSE where persistence functionality can be dynamically added or removed from running applications. By using this approach, persistence behavior can be added to existing applications without requiring to modify their original code. We present its flexible architecture, which allows the exploration of new forms of persistence extensions, and present performance data on the costs to persist the state of an application statically and dynamically.

@phdthesis{abc,
	abstract = {Dynamic adaptation is one of the greatest challenges for software engineering and is increasingly important, as the computing environments continue to expand and diversify. 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.
The research presented in this dissertation addresses this challenge. The first part of this dissertation presents PROSE, an infrastructure that supports dynamic adaptation by extending applications at runtime. The system performs reversible and systematic changes to running Java applications without requiring them to be shut down. 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. The modifications are expressed as Java classes, providing additional development benefits. We describe the architecture of PROSE, the challenges of using aggressive inlining to achieve high performance, and use standard benchmarks to demonstrate code performance comparable with, or better than, compile time systems from the Aspect-Oriented Programming community.
There is a growing number of applications which need to run continuously for a long period of time and have long-lived objects which need to be made persistent. The second part of this dissertation presents the application of PROSE in the implementation of dynamic persistence. That is persistence becomes not only an orthogonal concern but one that can be added to an application at runtime without interrupting its operations. With dynamic persistence we make the application independent of the container, so it can move from container to container and be made persistent at runtime without having to stop or redeploy the code. Our approach is a dynamic infrastructure based on PROSE where persistence functionality can be dynamically added or removed from running applications. By using this approach, persistence behavior can be added to existing applications without requiring to modify their original code. We present its flexible architecture, which allows the exploration of new forms of persistence extensions, and present performance data on the costs to persist the state of an application statically and dynamically.},
	author = {Angela Nicoara},
	school = {17571},
	title = {Controlled, Systematic, and Efficient Code Replacement for Running Java Programs},
	year = {2007}
}