Cheng B.H.C., de Lemos R., Paola H.G., Magee I.J. (eds.) Software Engineering for Self-Adaptive Systems

Подождите немного. Документ загружается.

142 O. Nierstrasz, M. Denker, and L. Renggli

syntax trees, which enables both dynamic and ﬁne-grained adaptation. Further-

more, by means of partial behavioural reﬂection, adaptations can be scoped

to the dynamic context. As a typical example, run-time instrumentation can

be scoped to the context of a given feature, so it is possible to identify which

software components support a given feature.

Diesel is a new framework for bringing models closer to code by supporting

the deﬁnition of lightweight DSLs that are transformed to the host program-

ming language using the same high-level source code models as provided by

Reﬂectivity. The development tools, such as editors and debuggers, are aware

of the transformations, so developers can continue to work with the high-level

models rather than the transformed code, even while debugging. Here too, run-

time models are used to support ﬁne-grained adaptations that can be scoped to

speciﬁc parts of the application requiring these DSLs.

Reﬂectivity and Diesel both build on top of the same rich programming envi-

ronment and therefore could proﬁt from each other in the future. On one hand,

the causal connection of model and code would help Diesel to automatically

propagate language changes to all its users. Furthermore Diesel could apply

language transformations that normally happen at compile-time from the dy-

namic world. On the other hand, Reﬂectivity could proﬁt from a richer language

infrastructure and the compiler plugins could reuse the Diesel transformations.

These are only two examples of promising research directions to support dy-

namic change and software adaptation. We argue that more research is needed

to close the gap between models and code. In general, software systems need to

be change-enabled — instead of limiting and restricting change, they should ac-

tively enable change by treating change as a ﬁrst-class entity [30,31]. Ultimately

we want model-centric and context-oriented programming environments where

we can directly manipulate models both during development time and run-time,

and software can be dynamically adapted by context.

Acknowledgments. We gratefully acknowledge the ﬁnancial support of the

Swiss National Science Foundation for the project “Bringing Models Closer to

Code” (SNF Project No. 200020-121594, Oct. 2008 - Sept. 2010).

We thank Tudor Gˆırba and Jorge Ressia for their careful reviews of various

drafts. We also thank the anonymous reviewers for their numerous suggestions

on how to improve the presentation of this paper.

References

1. Antkiewicz, M., Czarnecki, K.: Framework-speciﬁc modeling languages with round-

trip engineering. In: Nierstrasz, O., Whittle, J., Harel, D., Reggio, G. (eds.) MoD-

ELS 2006. LNCS, vol. 4199, pp. 692–706. Springer, Heidelberg (2006)

2. Atkinson, M.P., Buneman, O.P.: Types and persistence in database programming

languages. ACM Computing Surveys 19(2), 105–170 (1987)

3. Bawden, A.: Quasiquotation in Lisp. In: Partial Evaluation and Semantic-Based

Program Manipulation, pp. 4–12 (1999)

Model-Centric, Context-Aware Software Adaptation 143

4. B´ezivin, J., Gerb´e, O.: Towards a precise deﬁnition of the OMG/MDA framework.

In: Proceedings of Automated Software Engineering (ASE 2001), pp. 273–282.

IEEE Computer Society, Los Alamitos (2001)

5. Budinsky, F., Steinberg, D., Merks, E., Ellersick, R., Grose, T.: Eclipse Modeling

Framework. Addison Wesley Professional, Reading (2003)

6. Chiba, S., Kiczales, G., Lamping, J.: Avoiding confusion in metacircularity: The

meta-helix. In: Futatsugi, K., Matsuoka, S. (eds.) ISOTAS 1996. LNCS, vol. 1049,

pp. 157–172. Springer, Heidelberg (1996)

7. Costanza, P., Hirschfeld, R.: Language constructs for context-oriented program-

ming: An overview of ContextL. In: Proceedings of the Dynamic Languages Sym-

posium (DLS) 2005, co-organized with OOPSLA 2005, pp. 1–10. ACM, New York

(2005)

8. Czarnecki, K., Eisenecker, U.W.: Generative programming: methods, tools, and

applications. ACM Press/Addison-Wesley Publishing Co., New York (2000)

9. Denker, M.: Sub-method Structural and Behavioral Reﬂection. PhD thesis, Uni-

versity of Bern (May 2008)

10. Denker, M., Ducasse, S., Lienhard, A., Marschall, P.: Sub-method reﬂection. Jour-

nal of Object Technology, Special Issue (2007); Proceedings of TOOLS Europe

2007, vol. 6/9, pp. 231–251 (2007)

11. Denker, M., Gˆırba, T., Lienhard, A., Nierstrasz, O., Renggli, L., Zumkehr, P.:

Encapsulating and exploiting change with Changeboxes. In: Proceedings of the

2007 International Conference on Dynamic Languages (ICDL 2007), pp. 25–49.

ACM Digital Library, New York (2007)

12. Denker, M., Greevy, O., Lanza, M.: Higher abstractions for dynamic analysis. In:

2nd International Workshop on Program Comprehension through Dynamic Anal-

ysis (PCODA 2006), pp. 32–38 (2006)

13. Denker, M., Greevy, O., Nierstrasz, O.: Supporting feature analysis with runtime

annotations. In: Proceedings of the 3rd International Workshop on Program Com-

prehension through Dynamic Analysis (PCODA 2007), pp. 29–33. Technische Uni-

versiteit Delft (2007)

14. Denker, M., Suen, M., Ducasse, S.: The meta in meta-object architectures. In:

Proceedings of TOOLS EUROPE 2008. LNBIP, vol. 11, pp. 218–237 (2008)

15. van Deursen, A., Klint, P.: Little languages: Little maintenance? In: Kamin, S.

(ed.) First ACM-SIGPLAN Workshop on Domain-Speciﬁc Languages, DSL 1997,

January 1997, pp. 109–127 (1997)

16. Fowler, M.: Language workbenches: The killer-app for domain-speciﬁc languages

(June 2005), http://www.martinfowler.com/articles/languageWorkbench.html

17. Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Patterns: Elements of

Reusable Object-Oriented Software. Addison Wesley, Reading (1995)

18. Gonz´alez, S., Mens, K., Heymans, P.: Highly dynamic behaviour adaptability

through prototypes with subjective multimethods. In: DLS 2007: Proceedings of

the 2007 symposium on Dynamic languages, pp. 77–88. ACM, New York (2007)

19. Haldimann, N., Denker, M., Nierstrasz, O.: Practical, pluggable types for a dynamic

language. Journal of Computer Languages, Systems and Structures 35(1), 48–64

(2009)

20. Haustein, S., Pleumann, J.: A model-driven runtime environment for web applica-

tions. Software and System Modeling 4(4), 443–458 (2005)

21. Hirschfeld, R., Costanza, P., Nierstrasz, O.: Context-oriented programming. Jour-

nal of Object Technology 7(3) (March 2008)

22. Kiczales, G., des Rivi`eres, J., Bobrow, D.G.: The Art of the Metaobject Protocol.

MIT Press, Cambridge (1991)

144 O. Nierstrasz, M. Denker, and L. Renggli

23. Kiczales, G., Lamping, J., Mendhekar, A., Maeda, C., Lopes, C., Loingtier, J.-

M., Irwin, J.: Aspect-Oriented Programming. In: Aksit, M., Matsuoka, S. (eds.)

ECOOP 1997. LNCS, vol. 1241, pp. 220–242. Springer, Heidelberg (1997)

24. Knuth, D.E.: Literate Programming. Center for the Study of Language and Infor-

mation, Stanford (1992)

25. Krahn, H., Rumpe, B., V¨olkel, S.: Integrated deﬁnition of abstract and concrete

syntax for textual languages. In: Engels, G., Opdyke, B., Schmidt, D.C., Weil, F.

(eds.) MODELS 2007. LNCS, vol. 4735, pp. 286–300. Springer, Heidelberg (2007)

26. Lehman, M., Belady, L.: Program Evolution: Processes of Software Change. Aca-

demic Press, London (1985)

27. Magee, J., Dulay, N., Eisenbach, S., Kramer, J.: Specifying distributed software

architectures. In: Botella, P., Sch¨afer, W. (eds.) ESEC 1995. LNCS, vol. 989, pp.

137–153. Springer, Heidelberg (1995)

28. Marschall, P.: Persephone: Taking Smalltalk reﬂection to the sub-method level.

Master’s thesis, University of Bern (December 2006)

29. Nelson, S., Pearce, D.J., Noble, J.: First class relationships for OO languages. In:

Proceedings of the 6th International Workshop on Multiparadigm Programming

with Object-Oriented Languages (MPOOL 2008) (2008)

30. Nierstrasz, O., Denker, M., Gˆırba, T., Lienhard, A.: Analyzing, capturing and

taming software change. In: Proceedings of the Workshop on Revival of Dynamic

Languages (co-located with ECOOP 2006) (July 2006)

31. Nierstrasz, O., Denker, M., Gˆırba, T., Lienhard, A., R¨othlisberger, D.: Change-

enabled software systems. In: Wirsing, M., Banˆatre,J.-P.,H¨olzl, M. (eds.) Chal-

lenges for Software-Intensive Systems and New Computing Paradigms. LNCS,

vol. 5380, pp. 64–79. Springer, Heidelberg (2008)

32. Nixon, B., Chung, L., Mylopoulos, J., Lauzon, D., Borgida, A., Stanley, M.: Im-

plementation of a compiler for a semantic data model: Experiences with taxis. In:

SIGMOD 1987: Proceedings of the 1987 ACM SIGMOD international conference

on Management of data, pp. 118–131. ACM, New York (1987)

33. Odersky, M.: Scala language seciﬁcation v. 2.4. Technical report,

Ecole Polytech-

nique F´ed´erale de Lausanne, 1015 Lausanne, Switzerland (March 2007)

34. Ousterhout, J.K.: Scripting: Higher level programming for the 21st century. IEEE

Computer 31(3), 23–30 (1998)

35. Pawson, R.: Naked Objects. Ph.D. thesis, Trinity College, Dublin (2004)

36. Renggli, L., Ducasse, S., Kuhn, A.: Magritte — a meta-driven approach to empower

developers and end users. In: Engels, G., Opdyke, B., Schmidt, D.C., Weil, F. (eds.)

MODELS 2007. LNCS, vol. 4735, pp. 106–120. Springer, Heidelberg (2007)

37. Renggli, L., Nierstrasz, O.: Transactional memory in a dynamic language. Journal

of Computer Languages, Systems and Structures 35(1), 21–30 (2009)

38. Rivard, F.: Smalltalk: a reﬂective language. In: Proceedings of REFLECTION

1996, April 1996, pp. 21–38 (1996)

39. Rodr´ıguez, L., Tanter,

E., Noy´e, J.: Supporting dynamic crosscutting with par-

tial behavioral reﬂection: a case study. In: Proceedings of the XXIV International

Conference of the Chilean Computer Science Society (SCCC 2004), Arica, Chile.

IEEE, Los Alamitos (2004)

40. R¨othlisberger, D., Denker, M., Tanter,

E.: Unanticipated partial behavioral reﬂec-

tion: Adapting applications at runtime. Journal of Computer Languages, Systems

and Structures 34(2-3), 46–65 (2008)

41. R¨othlisberger, D., Greevy, O., Nierstrasz, O.: Exploiting runtime information in

the IDE. In: Proceedings of the 16th International Conference on Program Com-

prehension (ICPC 2008), pp. 63–72. IEEE Computer Society, Los Alamitos (2008)

Model-Centric, Context-Aware Software Adaptation 145

42. Schmidt, D.C.: Guest editor’s introduction: Model-driven engineering. Com-

puter 39(2), 25–31 (2006)

43. Shaw, M., Garlan, D.: Software Architecture: Perspectives on an Emerging Disci-

pline. Prentice-Hall, Englewood Cliﬀs (1996)

44. Sheard, T.: Accomplishments and research challenges in meta-programming. In:

Taha, W. (ed.) SAIG 2001. LNCS, vol. 2196, pp. 2–44. Springer, Heidelberg (2001)

45. Tanter, E.: Reﬂection and open implementations. Technical report, University of

Chile (2004)

46. Tanter,

E., Gybels, K., Denker, M., Bergel, A.: Context-aware aspects. In: L¨owe,

W., S¨udholt, M. (eds.) SC 2006. LNCS, vol. 4089, pp. 227–242. Springer, Heidelberg

(2006)

47. Tanter,

E., Noy´e, J., Caromel, D., Cointe, P.: Partial behavioral reﬂection: Spa-

tial and temporal selection of reiﬁcation. In: Proceedings of OOPSLA 2003, ACM

SIGPLAN Notices, November 2003, pp. 27–46 (2003)

48. Tratt, L.: Domain speciﬁc language implementation via compile-time meta-

programming. ACM TOPLAS 30(6), 1–40 (2008)

49. Warth, A., Piumarta, I.: OMeta: an object-oriented language for pattern matching.

In: DLS 2007: Proceedings of the 2007 symposium on Dynamic languages, pp. 11–

19. ACM, New York (2007)

50. Wirsing, M., H¨olzl, M. (eds.): Report of the Beyond the Horizon thematic group 6

on Software Intensive Systems (2006)

B.H.C. Cheng et al. (Eds.): Self-Adaptive Systems, LNCS 5525, pp. 146–163, 2009.

Modeling of Context-Aware Self-Adaptive Applications

in Ubiquitous and Service-Oriented Environments

Kurt Geihs, Roland Reichle, Michael Wagner, and Mohammad Ullah Khan

Universität Kassel, Wilhelmshöher Allee 73,

34121 Kassel, Germany

{geihs,reichle,wagner,khan}@vs.uni-kassel.de

Abstract. Mobile computing in ubiquitous environments has to cope with both

predictable and unpredictable changes in the execution context, which intro-

duces the need for context-aware adaptive applications. Such environments are

also characterized by dynamically discoverable services that can be utilized by

applications to improve their functionality and quality of service (QoS). Thus,

application adaptation decisions not only depend on context properties, but also

on service availability and QoS-properties. In this chapter we present a novel

comprehensive modeling approach that facilitates the model-driven develop-

ment of such applications. Our focus is on modeling concepts which align the

description of services and their QoS-properties with the context modeling ap-

proach. We provide a harmonized view on context and service properties,

bridging the syntactical and semantic differences through an ontology. We also

consider related aspects like semantic service discovery and service level

agreements.

Keywords: context awareness, compositional adaptation, ontology, service-

oriented architecture, ubiquitous computing, utility function.

1 Introduction

Mobile computing in ubiquitous environments triggers a need for dynamically adapt-

able applications that can be reconfigured during run-time, in order to remain useful

under the changing context situation. For example, an application may need to adapt

when connectivity changes, battery is running low, user preferences change, some

specific sensor value exceeds a predefined threshold, or services or devices appear or

disappear.

Context-aware adaptive applications based on component frameworks have been a

subject of intensive research for several years. Adaptation usually involves a recon-

figuration of the component composition to suit the changed context. In the EU-IST

project MUSIC [1] we explore an advanced kind of compositional adaptation by con-

sidering dynamically discovered services as possible replacements for application

components. Clearly, this opens up new possibilities as well as challenges for the

application adaptation. In the companion chapter “MUSIC: Middleware Support for

Self-Adaptation in Ubiquitous and Service-Oriented Environments” [20] in this vol-

ume a new planning framework has been introduced that supports self-adaptation of

mobile applications with regard to changes in the service landscape. By the term

Modeling of Context-Aware Self-Adaptive Applications 147

‘planning’ we refer to the computation and evaluation of alternative application con-

figurations in response to context changes and the selection of a feasible configura-

tion, best-fitted for the current context situation.

Our adaptation approach extends compositional adaptation by adding service-based

adaptation. Services can be dynamically discovered and bound by applications. A

newly discovered service may replace a component (or another service) in a compo-

nent-based application if it increases the overall application utility. Our adaptation

planning framework takes service properties and service level agreements into ac-

count when computing an adaptation decision in reaction to a context change.

A major goal of our research is to facilitate the development of self-adaptive appli-

cations. We adopt a model-driven development approach that builds on available

modeling languages for service-oriented computing with regard to functionality, inter-

faces, QoS-properties and semantic properties. The main contribution of this chapter

is a new modeling framework that explicitly addresses heterogeneity aspects that arise

from the independent development of services, context sensors and reasoners, as well

as the application itself. It provides a coherent set of concepts and a modeling meth-

odology that integrate seamlessly into an adaptation planning framework for context-

aware, component-based adaptive applications. The modeling concepts have been

designed such that the description of services and their QoS-properties align with the

context model. Since both QoS-properties and the context model are based on a

coherent set of ontologies, our approach achieves the bridging of syntactical and se-

mantic differences. Thus, it provides a harmonized, integrative view on context and

service properties. Furthermore, it also covers aspects like semantic service discovery

and service level agreements.

The chapter is organized as follows. We start with a motivating scenario in section 2.

In section 3 we identify the requirements of context-aware adaptive applications in

ubiquitous computing environments that serve as a guideline for our work. The main

concepts of the new application variability model and the adaptation reasoning approach

are explained in section 4. The integration of service-based adaptation is presented in

section 5. Section 6 explains the approach using a modeling example based on the sce-

nario of section 2. Related work is discussed in section 7. Section 8 concludes the chap-

ter and presents perspectives for future work.

2 Motivating Scenario

The following scenario shall motivate the need for service-based adaptations. A sales

agent visits customers and uses a context-aware Customer Relationship Management

(CRM) system, which offers functions like accessing and sharing customer- and busi-

ness-related information, route planning, calculation of travelling delays and notifying

people, who are affected by delays.

Scene 1: The sales agent meets a customer and uses the CRM system on his

smart-phone to record agreements. During the meeting he is notified about a new

appointment at another customer site and decides to prepare for it. He uses the CRM

application on his smart-phone to find the best route and to estimate the travel time.

For this, the application uses a navigation service provided over the WLAN at the

customer site and a traffic information service available through the Internet. There

148 K. Geihs et al.

are several providers for both of these services, and the CRM application selects the

one that offers a quick and precise solution to the agent.

Scene 2: After the meeting, the agent walks out of the customer’s building and gets

into the car to head for the next meeting. As he moves away from the customer site,

the smart-phone loses connection to the customer WLAN, and the Internet connection

is switched seamlessly to GPRS by the mobile IP software installed on the smart-

phone. The connection to the navigation service, which the CRM application needs to

monitor the progress towards the destination, is lost. The GPRS provider also offers a

navigation service, but with a rather low accuracy. The car has a navigation system

based on GPS, which provides not only a more accurate navigation service via a Blue-

tooth connection but also a better display. The CRM application automatically recon-

figures itself to use these services. It also saves battery life on the smart-phone by off-

loading local processing to the external services.

Scene 3: Halfway to the meeting, the agent runs into a traffic jam. The CRM applica-

tion detects this situation, alerts the agent that he will be late, estimates the delay

using data obtained from the traffic information service and offers the agent to notify

affected customers. The agent validates this proposal and the CRM application sends

messages to the customers.

Our goal is to provide generic support for such kind of automatic service-based ad-

aptations. Therefore, we have developed appropriate modeling concepts and inte-

grated them into a planning framework for compositional adaptation.

3 Requirements

In order to facilitate the development and operation of context-aware self-adaptive

applications in ubiquitous environments, we provide a model-driven development

approach, an adaptation middleware, and suitable development tools. The middleware

separates context sensing, adaptation reasoning and application reconfiguration from

the pure application logic. It provides a generic and reusable infrastructure for a wide

range of adaptive applications. See [20] for details of the middleware and the adapta-

tion approach. The middleware is complemented by a model-driven development

approach that allows the specification of application adaptation capabilities at a high

and platform-independent level and facilitates automatic generation of source-code

tailored for the middleware.

In order to realize context-aware adaptive applications in ubiquitous environments,

the adaptation approach and the adaptation models have to cope with the following

requirements:

• Application variability: Dynamic reconfigurations and reasoning about different

configuration alternatives require the definition of an application variability model

by the application developer. Since adaptations are intended to maximize the QoS

perceived by the user, the variability model has to be enriched with QoS-metadata

of the involved components.

• Dynamic service discovery: Ubiquitous computing environments are assumed to

offer services that can be discovered and accessed dynamically at runtime. This

requires specification means for the integration of external services into the

Modeling of Context-Aware Self-Adaptive Applications 149

application variability model. Their QoS-properties must be made available for the

adaptation reasoning process. Therefore, support for semantic service discovery,

semantic description of QoS-properties and service level negotiations is required.

• Heterogeneity: Services in ubiquitous computing environments may have been

developed independently by different parties. This implies that QoS-properties of

services may have different names and representations. Likewise, heterogeneity

may be found with the context management components, in particular if third

party context sensors and reasoners are integrated. Thus, QoS-properties and con-

text information that describe the properties of the execution context have to be

semantically enriched in order to enable interoperability and integration.

• Integration of service and context properties into the planning: The adaptation

planning is responsible for evaluating the usefulness of alternative application

configurations under a given context situation. Therefore, QoS-properties of avail-

able components and services have to be related to the properties of the execution

context.

In particular with respect to the heterogeneity aspect, we argue that a comprehensive

modeling notation is required to provide a common vocabulary that enables develop-

ers of different components to share a harmonized semantic view on the QoS-

properties of involved components/services and the properties of the execution

context. Our ontology-based modeling approach, as discussed in the following sec-

tions, provides such a vocabulary and thus eases the development task. Without such

kind of support, bridging syntactical and semantic differences of QoS-properties and

context information and their mediation is hard to achieve. Furthermore, the modeling

concepts have to be aligned to the underlying adaptation planning framework and

have to include provisions for semantic service discovery and description of service

levels and service level agreements.

In a previous publication [16], we already presented an ontological framework for

context modeling. Here we present a very substantial enhancement and generalization

of that approach by considering the additional aspects and challenges arising from a

service-oriented ubiquitous computing environment.

4 Application Variability and Adaptation Reasoning

The following explanations require a basic understanding of the underlying adaptation

approach. Therefore, we shortly describe its most important concepts. For a more

detailed description the reader is referred to our companion chapter [20] that presents

the corresponding run-time support for planning and execution of adaptations.

Applications are based on a component framework model that supports dynamic

reconfiguration at run-time. When there is a significant context change the middle-

ware evaluates and compares all available application variants based on different

QoS-metadata associated to the involved component realizations. Thus we consider

applications that are developed with a QoS-oriented component model, which defines

all reasoning dimensions used by the planning-based middleware to select and deploy

the component implementation that provides the best utility.

The utility of a component configuration is computed using a developer-defined

utility function. Those parts of the application that are evaluated during planning are

150 K. Geihs et al.

Application

Composite

Component

Atomic

Component

Type

Atomic

Realization

Plan

Composite

Realization

Plan

Component

is a

realize

described by

descibed by

describe

realization o

specialize

stpecnoctnenopmoCnoitpircsedlevel-ateM

Fig. 1. Creating application variants

called variation points. Each variation point identifies a functionality of the applica-

tion that can have different realizations. In our case the variation points are compo-

nent types corresponding to a certain part-functionality of the application. Each

component implementation suitable for a variation point is reified as a plan, which

mainly consists of a meta-structure that reflects the properties of the component im-

plementation. A plan exhibits both requested properties (e.g., memory consumption,

network bandwidth, monetary cost) and offered properties (e.g., throughput, response

time, result accuracy) referring to the QoS model of the application. Property predic-

tors help estimating the offered properties of the component associated with a plan.

They predict the values of non-functional offered properties of a component (or com-

ponent composition) as a function of required properties depending on a given execu-

tion context. These predicted property values are input arguments to a normalized

utility function to obtain the expected utility of the component in the given context.

The planning middleware compares the expected utility of all alternate component

configurations, and finally selects the one that provides the highest utility value.

Figure 1 illustrates that an application is viewed as a Component Type that can

have different realizations. The details and the QoS-properties of a certain realization

are described using Plans. Corresponding to the atomic and composite component

types, there are two types of Plans: Atomic Realization and Composite Realization.

An Atomic Realization Plan describes an atomic component and contains just a refer-

ence to the class or the data structure that realizes the component. The Composite

Realization Plan describes the internal structure of a composite component by speci-

fying the involved Component Types and the connections between them.

Variation is obtained by describing a set of possible realizations of a Component

Type using Plans. In order to create a possible variant, one of the Plans of a Compo-

nent Type is selected. If the Plan is a Composite Realization Plan, it describes a col-

laboration structure of further Component Types, which in turn are described by Plans

again. Now we proceed by recursively selecting one realizing Plan for every involved

Component Type. The recursion stops if an Atomic Realization Plan is chosen. There-

fore, by resolving the variation points we create application variants that correspond

to a certain composition of components depending on the plans that are chosen for

each of the Component Types.

Modeling of Context-Aware Self-Adaptive Applications 151

With service-based adaptation a part-functionality may be provided through a dy-

namically discoverable and accessible service. Thus, compositional adaptation is

extended by taking a service as a possible realization of a Component Type. To do so,

the QoS-properties, interfaces and binding information have to be included in a corre-

sponding plan.

Service discovery protocols integrated in the middleware advertise any newly dis-

covered services to a plan broker. Plans for these services and from known service

repositories are generated from service level descriptions so that they are available

when the planner initiates an adaptation at a later time. Of course, plans are discarded

when services become unavailable to the middleware and an adaptation process is

triggered if a service described by the discarded plan is currently in use.

A service might offer a predefined set of service levels. Then, for each service

level a separate plan is generated by the plan broker. Thus, the planning framework is

able to take service levels into account when planning the adaptation.

Two kinds of property predictors, representing service levels, can be associated

with plans. If the service level is fixed, then the property predictors report the values

defined in the SLA contracts associated with the plan. In case of a choice of service

levels, the property predictors iterate over the service level property values to calcu-

late the utility of the application variant.

5 Modeling of Service-Based Adaptation

Our modeling notation provides means for the creation of the application variability

model together with QoS-metadata, property predictors and utility functions. It also

facilitates the semantic description of the execution environment, in terms of context

and resource models, and includes specification means for external services, service

levels and service level agreements. In the following we focus on the specific model-

ing concepts for the integration of external services into compositional adaptation.

5.1 Semantic Annotation of Variation Points

The variability model consists of application type, component types and realizing

plans. We have developed a new UML Profile [12] to support such modeling tasks. In

order to consider services as a possible replacement for certain components, the corre-

sponding component types have to be annotated with a set of descriptions specifying

the expected functionality, the required interfaces and the expected set of QoS-

properties. Such annotations are only required for component types that may be the

target of dynamic service discovery. Clearly, core components that are crucial for the

general functionality of the application will most likely not be candidates for dynamic

substitution by externally provided services.

The semantic web community has addressed very similar challenges with regard to

semantic service discovery and matching. We intend to reuse their approaches and

modeling support as much as possible and thus, we associate OWL-S descriptions to

the corresponding component types. As we only want to state our requirements for an

external service, only the service profile and process model are needed, while the

service grounding is omitted. However, we avoid, as far as possible, that a developer