Programming Overhead: R1-R4

The programming overhead is a very critical point in terms of convincing a programmer to use dynamic adaptation instead of traditional solutions, e.g. conditional branches (s. section ), which covers all known environments.

R1

The integration of the adaptable parts into the core should be possible without any meta language, specifying any interfaces or dependencies of adaptable parts. The same programming language which is used for the rest of the mobile code should be applied for the adaptable parts, to specify their environmental conditions and to put together the whole mobile code. It does not forbid the deployment of different programming languages in the application, but the code fragments where adaptable parts are used, should not imply special tags or other markers that are not conform with the syntax of the language of the surrounding program code.

The reason for this rule is the kind of compilers, syntax checkers, visualization tools, etc. which are used to develop the mobile code. Only tools for common languages should be necessary and reduce the effort for installing and maintaining the programming environment.

R2

The second requirement improving the convenience for the application programmer is a qualitative requirement: minimal increase of ``lines of code''. This demand emerges from the direct comparison of an implementation using dynamic adaptation and an traditional implementation providing support for different environments (s. section ). Another unit of measurement could be the number of classes, if an object-oriented (OO) language is used.

R3

Support for easy maintenance can be achieved by a compact and integrated structure of the additional information needed for adaptation. Such information contains the description of environments and the environmental condition of adaptable parts.

R4

An assistance to the application programmer and an increase of stability of the mobile code is the indication and elimination of errors due to adaptation already at compilation time. Following conditions should be ensured by compilation:

• fitting interface between core and adaptable parts
• type safe invocation of adaptable methods
• validity of environmental condition for adaptable parts

The last requirement is an ill-defined requirement because it depends on the architecture of the adaptation mechanism which determines the kind of faults that can occur and therefore should be checked at compilation.

These requirements may not guarantee a more sophisticated way to program mobile code which must handle different environments but they guarantee at least, that the effort for using dynamic adaptation is not noticeable higher than for the traditional method (s. section ). Beside the aspect of pure programming techniques it is also important to look at the interaction between the core and the adaptation mechanism.