Michael J. Oudshoorn

AdJava : automatic distribution of Java applications

The majority of the worlds computing resources remains idle most of the time. By using this resource pool, an individual computation may be completed in a fraction of time required to run the same computation on a single machine. However, distributing a program over a number of machines proves to be a tedious and difficult job. This paper introduces a system, called AdJava, which harnesses the computing power of these under-utilized heterogeneous computers by automatically distributing the user application across the available resources. In addition to providing transparent automatic distribution, AdJava provides load balancing and migration of distributed objects through the use of intelligent software agents. The system provides all this support without any programmer involvement and without modifying the Java Virtual Machine (JVM). AdJavas range of features, combined with its ease of use, makes it a powerful system for distributed computing.

Towards Autonomic Distribution of Existing Object Oriented Programs

By harnessing computational power of distributed heterogeneous resources, it is possible to build a large scale integrated system so that a centralized program is partitioned and distributed to those resources in a way that results in both efficient execution of the program and maximized resource utilization. However, building such a system is a staggering challenge because of the associated complexities and required user intervention. This paper proposes an autonomic distributed architecture that statically analyzes the existing Java application, partitions it to self-managed components that handles the complexities related to distribution and coordination without user involvement. An efficient static analysis mechanism is implemented that identifies run time program instances and their dependencies in terms of a graph. It is observed that such a view of the program is essential towards self optimization and self management

Adding Self-Healing Capabilities into Legacy Object Oriented Application

Adding self healing functionalities into legacy applications without user involvement is immensely useful for users and programmers of such systems. This paper presents a technique of injecting user code with self-healing primitives by statically analyzing the legacy object oriented code and instrumenting it to become a self-manageable and self-healing component. Our experiments show that it is worthwhile to instrument legacy code to provide such autonomic behavior

An Autonomic Architecture for Legacy Systems

Incorporating autonomic functionality into applications without user involvement is useful not only for application programmers who are building distributed systems from scratch, but also for users of legacy systems. This paper proposes a technique of injecting user code with autonomic primitives by statically analyzing the legacy code and partitioning it to manageable autonomic components. To harvest the benefit of this approach, a transparent underlying autonomic architecture is proposed which requires minimal user interaction to operate. Our goal is to provide users and programmers of such systems with an easy to use environment to work within, fulfilling the vision of autonomic computing

Transformation of Existing Programs into Autonomic and Self-healing Entities

Autonomic computing is a grand challenge in computing, which aims to produce software that has the properties of self-configuration, self-healing, self-optimization and self-protection. Adding such autonomic properties into existing applications is immensely useful for redeploying them in an environment other than they were developed for. Such transformed applications can be redeployed in different dynamic environments without the user making changes to the application. However, creating such autonomic software entities is a significant challenge because of the amount of code transformation required. This paper presents feasible solutions to such code transformations and identifies associated issues. To illustrate such code transformations, a technique is presented that inserts Java byte code with self-healing primitives and transforms it to become a self-healing component. Experiments show that such code transformations are challenging however they are worthwhile in order to provide transparent autonomic behavior

Experience with a project-based approach to teaching software engineering

The paper reviews the experiences of teaching software engineering at the University of Adelaide using a group-based project over the course of one semester (15 weeks). Students are required to design, prototype, implement, maintain and document the software to satisfy the requirements defined by the lecturing staff who endeavour to simulate a customer as closely as possible. The paper focuses on the project and the benefits it offers rather than the content of the lectures.<<ETX>>

System Architecture of an Autonomic Element

An autonomic element is the fundamental building block of any autonomic system. Although different aspects of autonomic computing are explored in isolation, the structural operation of an autonomic element has not been completely modeled. The standard definition for an autonomic element does not provide an architectural blueprint and several proprietary designs have been proposed that are not interoperable with each other. This paper presents an engineering perspective of building a domain independent autonomic element. We believe that architectural choices have a profound effect on the capabilities of any autonomic system and affect many of the design decisions during its implementation. Therefore, it is important to have a well defined model of the basic building block to develop autonomic systems. The architectural design presented is self regulating and uses standard object oriented primitives to make it easy to develop and implement

Beyond Ada 95: The Addition of Persistence and Its Consequences

Research into persistent programming languages and systems in recent years has shown that the technology is useful for developing complex software in many problem domains. This paper explores the issues and consequences of adding persistence to Ada95. The persistence extensions support transparent migration of objects between a programs address space and a persistent store in a way that preserves both type safety and encapsulation of abstract data types.

Orthogonal persistence and Ada

Research into persistent programming languages and systems in recent years has shown that the technology is useful for developing complex software in many problem domains. This paper explores the issues of adding persistence support to Ada, either as extensions to Ada 9X, or as an integral part of the next version of the language.

Ambassadors: structured object mobility in worldwide distributed systems

In many distributed systems applications deployed on the worldwide scale, it is latency, rather than bandwidth, that is the primacy determinant of performance. This paper describes Ambassadors, a communication technique using mobile Java objects within an RPC/RMI-like communication structure. Ambassadors minimise the aggregate latency of sequences of inter-dependent remote operations by migration of code to the vicinity of the server to execute those operations. Furthermore, because Ambassadors migrate within an RPC/RMI-like structure communication has well defined failure semantics, an important characteristic in supporting effective software engineering of distributed systems.