Publications by Angela Nicoara

@inproceedings{abc,
	author = {Angela Nicoara and Gustavo Alonso and Timothy Roscoe},
	booktitle = {Proceedings of the 2008 EuroSys Conference, Glasgow, Scotland, UK},
	title = {Controlled, systematic, and efficient code replacement for running java programs.},
	url = {http://doi.acm.org/10.1145/1352592.1352617},
	venue = {Proceedings of the 2008 EuroSys Conference, Glasgow, Scotland, UK, April 1-4, 2008},
	year = {2008}
}

@inproceedings{abc,
	author = {Angela Nicoara and Gustavo Alonso},
	booktitle = {Proceedings of the 23rd International Conference on Data Engineering, ICDE 2007, The Marmara Hotel, Istanbul, Turkey},
	title = {Making Applications Persistent at Run-time.},
	url = {http://dx.doi.org/10.1109/ICDE.2007.369013},
	year = {2007}
}

@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}
}

@inproceedings{abc,
	author = {Angela Nicoara and Gustavo Alonso},
	booktitle = {Proceedings of the EclipseCon 2007, Santa Clara, CA, USA},
	title = {Runtime monitoring and adaptation of applications from Eclipse },
	year = {2007}
}

@inproceedings{abc,
	author = {Angela Nicoara and Gustavo Alonso},
	booktitle = {Advanced Information Systems Engineering, 17th International Conference, CAiSE 2005, Porto, Portugal},
	title = {Dynamic AOP with PROSE.},
	year = {2005}
}

@misc{abc,
	abstract = {PROSE (PROgrammable extenSions of sErvices), an open source project (http://prose.ethz.ch/), is an adaptive middleware platform based on Java for dynamic AOP which allows aspects to be woven, unwoven, or replaced at run time. Woven into a program, an aspect may change several units of functionality. Aspects are expressed in the same source language as the application (Java). PROSE provides middleware tools that allow run time monitoring of remote aspects. The PROSE workbench for weaving, unweaving and querying aspects is a monitoring tool which displays information about what aspects are currently inserted in the system, what join-points belong to each aspect, and what the join-points of the system are. Embedded into an Eclipse plug-in, this tool is also used to developing and running PROSE applications from Eclipse and allows run time monitoring of remote aspects, and provides a creation wizard that helps to create PROSE aspects.

In this demonstration we present PROSE and its associated middleware tools. We show the flexibility of PROSE and how it has been embedded into Eclipse, and present a variety of examples of run time adaptation. In the first part of the demonstration we show how to modify the behavior of a running application by dynamically weaving an aspect that identifies places of interest in the application. After each weaving operation, we show that the running application has been adapted and we use the PROSE middleware tools to graphically display the join-points matched by the woven aspect. In the second part of the demonstration we show how easy is to create aspects that modify a program at run time using the creation wizard of the PROSE Development Tools for Eclipse. When an aspect is created, the user can select the PROSE crosscut types and pointcutters from a list. Then the code template for a PROSE aspect that defines an advice method and a poincut method will be generated. The aspects are then woven remotely into different VMs. After the weaving operation, we show that the running application has been adapted. In case of two running applications, we show that the aspects can be cut and pasted between distinct VMs using the PROSE workbench and also can be moved between distinct VMs by drag and drop using the PROSE plug-in for Eclipse. We also show how to insert and withdraw aspects transactionally. We start a transaction and then weave and unweave aspects into/from different VMs.

Aspect insertions and withdrawals won{\textquoteright}t be activated until the transaction is committed. The transaction can also be aborted, leaving the application as if no insertion or withdrawal ever took place.
},
	author = {Angela Nicoara and Gustavo Alonso},
	title = {PROSE - A middleware platform for dynamic adaptation},
	year = {2005}
}