Michael J. Oudshoorn
Montana State University
Network
Latest external collaboration on country level. Dive into details by clicking on the dots.
Publication
Featured researches published by Michael J. Oudshoorn.
ACSC '02 Proceedings of the twenty-fifth Australasian conference on Computer science - Volume 4 | 2002
M. Muztaba Fuad; Michael J. Oudshoorn
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.
international conference on autonomic and autonomous systems | 2006
Debzani Deb; M. Muztaba Fuad; Michael J. Oudshoorn
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
international conference on autonomic and autonomous systems | 2006
M. Muztaba Fuad; Debzani Deb; Michael J. Oudshoorn
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
Third IEEE International Workshop on Engineering of Autonomic & Autonomous Systems (EASE'06) | 2006
M. Muztaba Fuad; Michael J. Oudshoorn
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
engineering of computer based systems | 2007
M. Muztaba Fuad; Michael J. Oudshoorn
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
Proceedings Software Education Conference (SRIG-ET'94) | 1994
Michael J. Oudshoorn; Kevin Maciunas
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>>
Fourth IEEE International Workshop on Engineering of Autonomic and Autonomous Systems (EASe'07) | 2007
M. Muztaba Fuad; Michael J. Oudshoorn
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
international conference on reliable software technologies | 1996
Michael J. Oudshoorn; Stephen Crawley
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.
tri-ada | 1994
Stephen Crawley; Michael J. Oudshoorn
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.
international conference on distributed computing systems | 1999
Henry Detmold; Michael Hollfelder; Michael J. Oudshoorn
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.