M. Muztaba Fuad

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

An evaluation of Protocol Buffer

World is shrinking each day through the use of Internet and people are communicating better than before in this widely distributed network. There is a great need to manage this communication over various networks supporting different specifications. One of the widely used techniques for this type of data management is XML data interchange format. Google developers recently introduced Protocol Buffer as an alternative to XML claiming that it overcomes the shortcomings suffered by XML. This paper compares XML and Protocol Buffer data formats by extensive analysis of the two. The paper evaluates the claims made by Google by developing an algorithm to map an existing XML to Protocol Buffer format and drawing any conclusion on the efficiency and effectiveness of this format as compared to XML. It can be hoped that this work will contribute to the upcoming research in this field as people are looking for more robust data interchange format for the future of the Internet.

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

An Evidence Based Learning and Teaching Strategy for Computer Science Classrooms and Its Extension into a Mobile Classroom Response System

Evidence-based instructional practices were incorporated in class, which gave immediate indication on students problem solving skills and class participation information. This pedagogy showed positive results and broader acceptance by students in several semesters of intervention. Significant usage of mobile devices during class motivates the extension of this pedagogical approach of asynchronous problem solving using mobile devices. We believe that use of such devices in the classroom for solving interactive problems will enhance students abilities to solve problems by using their preferred interaction mode. This paper presents the results of the evidence based pedagogy and development of a mobile classroom response system that extends this pedagogy to help student solve interactive problems in their mobile devices to improve their class engagement and problem solving skills.

Using Interactive Exercise in Mobile Devices to Support Evidence-based Teaching and Learning

To improve students class experience, the use of mobile devices has been steadily increasing. However, such use of mobile learning environments in the class is mostly static in nature through content delivery or multiple choice and true/false quiz taking. In CS courses, we need learning environments where students can interact with the problem in a hands-on-approach and instructor can assess their learning skills in real-time with problems having different degree of difficulty. To facilitate such interactive problem solving and real-time assessment using mobile devices, a comprehensive backend system is necessary. This paper presents one such system, named Mobile Response System (MRS) software, associated interactive problem-solving activities, and lessons learned by using it in the CS classrooms. MRS provides instructor with the opportunity of evidence-based teaching by allowing students to perform interactive exercises in their mobile devices with different learning outcomes and by getting an instant feedback on their performance and mental models. MRS is easy-to-use, extensible and can render interactive exercises developed by third-party developers. The student performance data shows its effectiveness in increasing student understanding of difficult concepts and the overall perception of using the software was very positive.

Achieving self-managed deployment in a distributed environment

This paper proposes algorithms and mechanisms for achieving self-optimized deployment of computationally intensive scientific and engineering applications in highly dynamic and large-scale distributed environment. The primary focus is on the modeling of the application and underlying architecture into a common abstraction and on the incorporations of autonomic features to those abstractions to achieve self-optimized deployment. To represent the underlying heterogeneous infrastructure, a hierarchical (tree) model of distributed resources has been adopted that organizes distributed nodes in a utility aware way. To accomplish the self-optimization, a utility-function has been formulated that governs both the initial deployment of an application and its dynamic reconfiguration. In our approach, the deployment decisions are made solely based on locally available information and without costly global communication or synchronization. The self-management is therefore decentralized to provide better adaptability, scalability and robustness.