A distributed autonomic system adapts its constituent components to a changing environment. This paper reports on the application of autonomic management to a distributed storage service. We developed a simple analytic model which suggested potential benefit from tuning the degree of concurrency used in data retrieval operations, to suit dynamic conditions. We then validated this experimentally by developing an autonomic manager to control the degree of concurrency. We compared the resulting data retrieval performance with non-autonomic versions, using various combinations of network capacity, membership churn and workload patterns. Overall, autonomic management yielded improved retrieval performance. It also produced a distinct but not significant increase in network usage relative to one non-autonomic configuration, and a significant reduction relative to another.

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 /spl 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.

The changing needs of modern application systems demand new and radical software architectures to support them. The attraction of persistent systems is that they define precisely the extent to which they are open, thereby allowing the dynamically changing resource requirements of applications to be tracked accurately within the persistent environment. Thus, an ever-growing body of work is being established to study the nature of running applications, and to use the information gleaned, to improve the run-time execution of these applications. Here we propose a new architectural approach to constructing persistent systems that accommodates, and thus is compliant to, the needs of particular applications. By separating policy from mechanism in all components, the architecture may be tailored to the policy needs of the application. (Policy may be regarded as strategy for achieving a goal, such as a cache eviction algorithm, whereas mechanism is the method by which the objective is achieved, such as the physical movement of the cache lines. As we see later, policy and mechanism are composable to form new mechanism.) We first propose a generic architecture for compliance, and then show how it may be instantiated. Finally, we describe an example of how the architecture operates in a manner that is compliant to a target application. We postulate, since we have not yet measured, that the benefits of compliant architectures will be a reduction in complexity, with corresponding gains in flexibility, portability, understandability in terms of failure semantics, and performance. Copyright © 2000 John Wiley & Sons, Ltd.

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. © 1998 John Wiley & Sons, Ltd.

We demonstrate the use of a hyper-programming system in building persistent applications. This allows program representations to contain type-safe links to persistent objects embedded directly within the source code. The benefits include improved efficiency and potential for static program checking, reduced programming effort and the ability to display meaningful source level representations for first class procedure values. Hyper-programming represents a completely new style of programming which is only possible in a persistent programming system.

Persistent programming systems are designed to provide technology for the construction and maintenance of large, long-lived object-based application systems. Many successful prototypes have been constructed and a large body of application building experience is emerging. Three common attributes of persistent systems are persistent linkage, strong typing, and the referential integrity of data. Persistent linkage allows persistent objects to be included in the binding process. Strong typing guarantees that objects are only manipulated in a manner consistent with their type system descriptions. Referential integrity ensures that once a link (reference) to an object is established, its identity is unique and it persists over time. As a consequence no object can be deleted while another refers to it. Here we examine some of the advantages of providing software engineering environments within a persistent object system with strong typing and referential integrity. It is shown how the integration of system specifications, programs, configuration management tools and documentation all within a single persistent environment leads to powerful new techniques. This new power is achieved by sharing structured persistent data across the hitherto enclosing boundaries of system components.