VI Conclusions

  Our motivation for dynamic adaptation in this paper was to improve mobile agents in terms of efficency and flexibility (which translates into scaleability if applied to software and service management tasks), while avoiding undue complications and cost in terms of software engineering. In our approach, the code which is moved over the network is limited to the parts that are environment-independent and needed everywhere, and environment-dependent parts are only transferred when needed. On the software engineering side, we use a well-known design pattern to establish simple practice.

As a result of studying the state-of-the-art in software adaptation two styles have been identified: static adaptation, operating on the level of code, and continuous adaptation, operating on the level of instrumentation. Both cannot fulfill our demands immediately, but we conceptually drew from them to build our own adequate solution for dynamic adaptation. In particular, we have isolated and captured the concepts of reconfiguration and context awareness, respectively.

Aside from describing the overall concept and framework architecture, we have also implemented a Java-based prototype for dynamic adaptation. The framework consists of the following parts:

1.

An adaptor generator automates the creation of adaptors for the application programmer. The functionality interfaces are read by the adaptor generator and transformed into adaptor classes using Java reflection. The output of the adaptor generator is an adaptor class in Java source code format. As we use reflection, our implementation depends on the use of Java (or typically another interpreted programming language).

2.

The context awareness tools includes a pool of profiles, several commonly used profile values like operating system, CPU architecture, and instances which are needed for the example application in the domain of web browsers. Profile values for a future application can be added as needed. Furthermore the context awareness tool includes an execution environment for the profiles embedded into the adaptors.

3.

The loader extends the default Java class loader. It loads the appropriate implementation class as specified by the context awareness module, and prepares for dynamic linking against the Java adaptor class.

4.

Both the context awareness and the loader rely on the service of a repository which serves the implementation profiles and the implementation classes. In order to minimize the impact on the autonomy of the mobile agent we use proxy repositories. Proxy repositories reside on hosts close to the mobile agent and reduce communication overhead when loading profiles or implementation classes for adaptation, hence restricting actully occuring code migration not only in amount but also in geographic distance.

We are satisfied that dynamic adaptation has proved valuable for crafting agents that fulfill a dedicated task (such as software configuration) in a range of different environments (such as on heterougenous workstations) efficiently. In this paper, we have described our overall architecture and its prototype implementation with consistent reference to an illustrative use case.

Our main focus for future works concern security and performance related questions of mobile agent based management. Interesting problems in this context are, e.g., authentication of code sources of mobile agents and adaptable parts, their integrity, questions of responsibility for activities of mobile agents and access control for them, as well as a evaluation of their cummulative effect on performance, as opposed to what can be observed in a conventional scheme.