13,058 research outputs found
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
Evolving database systems : a persistent view
Submitted to POS7 This work was supported in St Andrews by EPSRC Grant GR/J67611 "Delivering the Benefits of Persistence"Orthogonal persistence ensures that information will exist for as long as it is useful, for which it must have the ability to evolve with the growing needs of the application systems that use it. This may involve evolution of the data, meta-data, programs and applications, as well as the users' perception of what the information models. The need for evolution has been well recognised in the traditional (data processing) database community and the cost of failing to evolve can be gauged by the resources being invested in interfacing with legacy systems. Zdonik has identified new classes of application, such as scientific, financial and hypermedia, that require new approaches to evolution. These applications are characterised by their need to store large amounts of data whose structure must evolve as it is discovered by the applications that use it. This requires that the data be mapped dynamically to an evolving schema. Here, we discuss the problems of evolution in these new classes of application within an orthogonally persistent environment and outline some approaches to these problems.Postprin
Variadic genericity through linguistic reflection : a performance evaluation
This work is partially supported by the EPSRC through Grant GR/L32699 âCompliant System Architectureâ and by ESPRIT through Working Group EP22552 âPASTELâ.The use of variadic genericity within schema definitions increases the variety of databases that may be captured by a single specification. For example, a class of databases of engineering part objects, in which each database instance varies in the types of the parts and the number of part types, should lend itself to a single definition. However, precise specification of such a schema is beyond the capability of polymorphic type systems and schema definition languages. It is possible to capture such generality by introducing a level of interpretation, in which the variation in types and in the number of fields is encoded in a general data structure. Queries that interpret the encoded information can be written against this general data structure. An alternative approach to supporting such variadic genericity is to generate a precise database containing tailored data structures and queries for each different instance of the virtual schema.1 This involves source code generation and dynamic compilation, a process known as linguistic reflection. The motivation is that once generated, the specific queries may execute more efficiently than their generic counter-parts, since the generic code is âcompiled awayâ. This paper compares the two approaches and gives performance measurements for an example using the persistent languages Napier88 and PJama.Postprin
Support for Evolving Software Architectures in the ArchWare ADL
Software that cannot evolve is condemned to atrophy: it cannot accommodate
the constant revision and re-negotiation of its business goals nor intercept
the potential of new technology. To accommodate change in software systems we
have defined an active software architecture to be: dynamic in that the
structure and cardinality of the components and interactions are changeable
during execution; updatable in that components can be replaced; decomposable in
that an executing system may be (partially) stopped and split up into its
components and interactions; and reflective in that the specification of
components and interactions may be evolved during execution. Here we describe
the facilities of the ArchWare architecture description language (ADL) for
specifying active architectures. The contribution of the work is the unique
combination of concepts including: a {\pi}-calculus based communication and
expression language for specifying executable architectures; hyper-code as an
underlying representation of system execution that can be used for
introspection; a decomposition operator to incrementally break up executing
systems; and structural reflection for creating new components and binding them
into running systems.Comment: 4th Working IEEE/IFIP Conference on Software Architecture (WICSA'04)
pp.69-78, IEEE Computer Society, 200
Models of higher-order, type-safe, distributed computation over autonomous persistent object stores
A remote procedure call (RPC) mechanism permits the calling of procedures in another
address space. RPC is a simple but highly effective mechanism for interprocess communication
and enjoys nowadays a great popularity as a tool for building distributed applications.
This popularity is partly a result of their overall simplicity but also partly a consequence
of more than 20 years of research in transpaxent distribution that have failed to deliver
systems that meet the expectations of real-world application programmers.
During the same 20 years, persistent systems have proved their suitability for building
complex database applications by seamlessly integrating features traditionally found in
database management systems into the programming language itself. Some research. effort
has been invested on distributed persistent systems, but the outcomes commonly suffer
from the same problems found with transparent distribution.
In this thesis I claim that a higher-order persistent RPC is useful for building distributed
persistent applications. The proposed mechanism is: realistic in the sense that it uses
current technology and tolerates partial failures; understandable by application programmers;
and general to support the development of many classes of distributed persistent
applications.
In order to demonstrate the validity of these claims, I propose and have implemented three
models for distributed higher-order computation over autonomous persistent stores. Each
model has successively exposed new problems which have then been overcome by the next
model. Together, the three models provide a general yet simple higher-order persistent
RPC that is able to operate in realistic environments with partial failures.
The real strength of this thesis is the demonstration of realism and simplicity. A higherorder
persistent RPC was not only implemented but also used by programmers without
experience of programming distributed applications. Furthermore, a distributed persistent
application has been built using these models which would not have been feasible with a
traditional (non-persistent) programming language
A Flexible and Secure Deployment Framework for Distributed Applications
This paper describes an implemented system which is designed to support the
deployment of applications offering distributed services, comprising a number
of distributed components. This is achieved by creating high level placement
and topology descriptions which drive tools that deploy applications consisting
of components running on multiple hosts. The system addresses issues of
heterogeneity by providing abstractions over host-specific attributes yielding
a homogeneous run-time environment into which components may be deployed. The
run-time environments provide secure binding mechanisms that permit deployed
components to bind to stored data and services on the hosts on which they are
running.Comment: 2nd International Working Conference on Component Deployment (CD
2004), Edinburgh, Scotlan
Report on the XBase Project
This project addressed the conceptual fundamentals of data storage,
investigating techniques for provision of highly generic storage facilities
that can be tailored to produce various individually customised storage
infrastructures, compliant to the needs of particular applications. This
requires the separation of mechanism and policy wherever possible. Aspirations
include: actors, whether users or individual processes, should be able to bind
to, update and manipulate data and programs transparently with respect to their
respective locations; programs should be expressed independently of the storage
and network technology involved in their execution; storage facilities should
be structure-neutral so that actors can impose multiple interpretations over
information, simultaneously and safely; information should not be discarded so
that arbitrary historical views are supported; raw stored information should be
open to all; where security restrictions on its use are required this should be
achieved using cryptographic techniques. The key advances of the research were:
1) the identification of a candidate set of minimal storage system building
blocks, which are sufficiently simple to avoid encapsulating policy where it
cannot be customised by applications, and composable to build highly flexible
storage architectures 2) insight into the nature of append-only storage
components, and the issues arising from their application to common storage
use-cases
Exploiting persistence in CASE technology
Bibliography: pages 102-107.A Design Workbench has been built for Napier88 [MBC+94] as part of the natural progression towards developing better product systems and improving software construction tools. The system includes a Metamodeller (enabling users to specify the data and process models they prefer), a Model Builder which supports multiple coexisting models and a Target System Generator. Experience using the Workbench has shown that it is easy to use, increases productivity, improves programming standards and facilitates code sharing. This thesis demonstrates the benefits of orthogonal persistence for Computer-Aided Software Engineering by describing an initial design environment and its subsequent extension to include support for multiple co-existing models
- âŚ