Context awareness and adaptation have become two key
aspects to be considered while developing applications and services for heterogeneous environments.
Applications and services need to be aware
of and adaptive to their context, i.e., the combination of
user-centric data (e.g., information of interest for users according
to their current circumstance) and resource/computer-centric data
(e.g., resource limits and conditions of devices and network).
Strictly concerning CHAMELEON, context awareness
identifies the capability of being aware of the user needs and of
the resources required by an application and offered by the hosting execution environment (e.g., processor,
memory, display, I/O capabilities, available radio interfaces, networks in reach), in
order to decide whether that environment is suited to receive and
execute the application in such a way that end-users expectations
are satisfied. Adaptation identifies the capability of
changing the application in order to comply with the current context
conditions. In order to perform an adaptation it is essential to
provide an actual way to model the characteristics of the
application itself and of the execution environment, aiming at a high end-user
degree of satisfaction depending on requested and offered SLS.
In this direction, we introduces the notion of requested Service Level
Specification (SLS) and offered SLS to deal with the
(extra-functional) preferences of the user.
Thus, while delivering services, it is useful to be able to reason
about the resources demanded by an application (and its
possible adaptation alternatives - i.e., different implementations)
and the ones supplied by
the hosting execution environment. It is worth to note that although a change
of context is measured in quantitative terms, i.e., in terms of
availability of (network and device) resources, an application can only be adapted by
changing its behavior - i.e., its functional/qualitative
specification.
In this setting, three different construction approaches towards
adaptable applications might be considered: (i)
self-contained applications that embed the adaptation
logic as a part of the application itself and, therefore, are
a-priori instructed on how to handle dynamic changes in the
environment hence reacting to them at runtime; (ii)
tailored applications that are the result of an adaptation
process which has been previously applied on a generic version of
the application; (iii) middleware-based adaptable
applications in which the middleware embeds the adaptation logic in
the form of meta-level information on how the applications can be
adapted. Self-contained adaptable applications are inherently
dynamic in their nature but suffer the pay-off of the inevitable
overhead imposed by the adaptation logic. On the contrary, tailored
adapted applications have a lighter code that make them suitable
also for limited devices, but are dynamic only with respect to the
environment at deployment time, while remaining static with respect
to the actual execution, i.e., they cannot self-adapt to runtime
changes in the execution environment. Considering the huge variety
and limitedness of our target devices, and the complexity of the
emergent networking enviroments (such as
Beyond 3rd Generation (B3G)
networks) would make unfeasible the deployment of a fully
self-adaptive application (i.e., a potentially huge-sized
self-contained application) suitable for any resulting
execution environment and possible context in which the user can
move.
The CHAMELEON framework is for tailored applications.
Paola
::©www.di.univaq.it/inverard
Marco
::©www.di.univaq.it/marco.autili
Paolo
::©www.di.univaq.it/paolo.dibenedetto
::last modified: --\--\--