10,788 research outputs found
A flexible model for dynamic linking in Java and C#
Dynamic linking supports flexible code deployment, allowing partially linked code to link further code on the fly, as needed.
Thus, end-users enjoy the advantage of automatically receiving any updates, without any need for any explicit actions on their side,
such as re-compilation, or re-linking. On the down side, two executions of a program may link in different versions of code, which
in some cases causes subtle errors, and may mystify end-users.
Dynamic linking in Java and C# are similar: the same linking phases are involved, soundness is based on similar ideas, and
executions which do not throw linking errors give the same result. They are, however, not identical: the linking phases are combined
differently, and take place in different order. Consequently, linking errors may be detected at different times by Java and C# runtime
systems.
We develop a non-deterministic model, which describes the behaviour of both Java and C# program executions. The nondeterminism
allows us to describe the design space, to distill the similarities between the two languages, and to use one proof of
soundness for both. We also prove that all execution strategies are equivalent with respect to terminating executions that do not
throw link errors: they give the same results
XMILE:An XML-based approach for programmable networks
In this paper we describe an XML-based platform for dynamic active node policy updates. XML supports the definitionof specific policy languages, their extension to satisfy new needs and the management of deployed policies on differentactive nodes. We show an example of the management of router packet forwarding policies where the XML policiesthat drive the packet routing are updated at run-time on the active nodes depending on the network status. The platformdecouples policy management, which is handled through XML interpretation, from packet forwarding that, forperformance reasons has to be implemented in more efficient languages
Experience with statically-generated proxies for facilitating Java runtime specialisation
Issues pertaining to mechanisms which can be used to change the behaviour of Java classes at runtime are discussed. The proxy mechanism is compared to, and contrasted with other standard approaches to this problem. Some of the problems the proxy mechanism is subject to are expanded upon. The question of whether statically-developed proxies are a viable alternative to bytecode rewriting was investigated by means of the JavaCloak system, which uses statically-generated proxies to alter the runtime behaviour of externally-developed code. The issues addressed include ensuring the type safety, dealing with the self problem, object encapsulation, and issues of object identity and equality. Some performance figures are provided which demonstrate the load the JavaCloak proxy mechanism places on the system
Towards a mobile computing middleware: a synergy of reflection and mobile code techniques
The increasing popularity of wireless devices, such as mobile phones, personal digital assistants, watches and the like. is enabling new classes of applications that present challenging problems to designers. Applications have to be aware of, and adapt to, frequent variations in the context of execution, such as fluctuating network bandwidth, decreasing batten, power, changes in location or device capabilities, and so on. In this paper, we argue that middleware solutions for wired distributed systems cannot be used in a mobile setting, as the principle of transparency that has driven their design runs counter to the new degrees of awareness imposed by mobility: We propose a synergy of reflection and code mobility as a means for middleware to give applications the desired level of flexibility to react to changes happening in the environment, including those that have not necessarily been foreseen by middleware designers. We ruse the sharing and processing of images as an application scenario to highlight the advantages of our approach
Linguistic Reflection in Java
Reflective systems allow their own structures to be altered from within. Here
we are concerned with a style of reflection, called linguistic reflection,
which is the ability of a running program to generate new program fragments and
to integrate these into its own execution. In particular we describe how this
kind of reflection may be provided in the compiler-based, strongly typed
object-oriented programming language Java. The advantages of the programming
technique include attaining high levels of genericity and accommodating system
evolution. These advantages are illustrated by an example taken from persistent
programming which shows how linguistic reflection allows functionality (program
code) to be generated on demand (Just-In-Time) from a generic specification and
integrated into the evolving running program. The technique is evaluated
against alternative implementation approaches with respect to efficiency,
safety and ease of use.Comment: 25 pages. Source code for examples at
http://www-ppg.dcs.st-and.ac.uk/Java/ReflectionExample/ Dynamic compilation
package at http://www-ppg.dcs.st-and.ac.uk/Java/DynamicCompilation
- ā¦