Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
Uncertainty Modeling of Self-adaptive Software Requirement 1,2
Wei Liu, 2Zaiwen Feng School of Computer Science and Engineering, Wuhan Institute of Technology 2 Hubei Key Laboratory of Intelligence Robot,Wuhan,430073, China,
[email protected] 3 State Key Lab of Software Engineering (SKLSE), Wuhan University, Wuhan 430072, China,
[email protected] 1
Abstract Service oriented computing utilizes services as fundamental elements for developing applications that have the capability to autonomously modify their behavior at run-time in response to the changes in their environment, which is especially suitable for designing and developing self-adaptive software. While uncertainty induced by randomness environment in service oriented self-adaptive software requirement is a well-studied activity, representing and analyzing uncertainty have not enjoyed equal attention. In this paper, we address this problem by amalgamating context snapshot with goal and business process model to support the representation of uncertainty for self-adaptive software requirements. We define a context snapshot model to represent requirement uncertainty with domain knowledge; context-specific goal-oriented requirement model is constructed for customer requirements and context-specific process-oriented requirement model is constructed for service requirements; and finally, propose means-c-end analysis to relate the customer requirements and service requirements with context condition. We illustrate and evaluate our approach through a case study about a city intelligent traffic information system.
Keywords: Requirement Evolution, Goal Modeling, Business Process Modeling, Context Snapshot 1. Introduction Software needs to dynamically adapt its behavior at run-time in response to changing conditions in the supporting computing, communication infrastructure, and in the surrounding environment [1]. Software engineering of service-oriented system could help software realizing the characters of self-adaptive [2]. Through discovering, mining and customizing adapting service resources, service oriented self-adaptive software (SoSAS) is able to modify its service behavior according to the changes in its continuing evolution requirement at runtime. Requirement analysis of SoSAS imposes challenge from conventional requirements analysis approaches. Comparing with the conventional requirements, SoSAS requirement has mainly two features. One feature is that the requirement could replace the action of software architecture in traditional process of software design and development, which enable the requirements both represent the abstract users’ demands and system design with web service characteristics, such as process (flow) of web service execution and service operation. However, whether object-oriented classical requirement models or widespread influence requirement models, such as goal-oriented requirement model[3], both could not present the web service characteristics. The other feature is that the environment information of system is transforming implicit into explicit and the adaptation of system is transforming static into dynamic. This phenomenon induces uncertainty of system and the uncertainty demands dynamic adaptation of system. So there are two most crucial problems on the study of SoSAS requirement analysis. Firstly, the uncertainty should be view as a constituent in the requirement and that is different from functional requirements and non-functional requirements in elicitation and analysis technologies. Unfortunately, few researches have focused on the uncertainty in requirement engineering. Ebert’ study discussed the underlying drivers for requirement uncertainty [4]. Secondly, how to describe the SoSAS requirements combined uncertainty. There is no systematic approach in assimilation of service-oriented software requirements and uncertainty description language. Although, RELAX [5] is proposed as a new requirements language for self-adaptive systems that explicitly addresses uncertainty inherent in adaptive systems, this structure nature language does not adaptive for service-oriented software requirements description.
International Journal of Advancements in Computing Technology(IJACT) Volume4, Number11, June 2012 doi: 10.4156/ijact.vol4.issue 11.9
87
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
In order for these challenges to be met, amalgamating context snapshot with goal and business process model to support the representation of uncertainty for self-adaptive software requirements is proposed in this paper. Context aware technology in pervasive computing could provide a feasible research direct for representing and analyzing uncertainty. This paper proposes a context snapshot fusion framework for representing and analysis SoSAS requirements, called ConUSER. Our proposal builds over customer requirements and service requirements models, therefore it is expected to amalgamate a context snapshot model to represent uncertainty in requirements with domain knowledge and expected to model customer requirement with domain-based goal and service requirement with domain-based business process. The paper is structured as follows. Sect. 2 illustrates the representation technique to derive requirements for different context snapshots, while Sect. 3 shows an approach to derive uncertainty in contextual requirements of SoSAS. Section 4 presents our developed ConUSER support tool and the results obtained by applying our framework on the case study. Related work and conclusion are given in Sects. 5 and 6, respectively.
2. Context snapshot based uncertainty representation Dealing with uncertainty has been outlined as a major research area facing the requirement engineering for self-adaptive software. In this section, we propose an uncertainty representation approach that model context snapshot with domain knowledge in domain-specific model.
2.1 Uncertainty definition A SoSAS environment for a particular application could include network, the service system, specific development tools or terminal. The environment is global, open, partly unknown and always unpredictable. An important changing takes place at the requirement level, which is SoSAS will continue to meet the needs of its stakeholders and environment. Parnas et al. [6] defined that “uncertainty requirement means that requirements are not known until it is practically used”. Uncertainty requirement is some requirements which may be elicited in special environments. For example, querying bus should considering congestion points in rush hour or road maintenance. Uncertainty means sustainable change environment information. The uncertainty could be regarded as context and be translated into context snapshot at a specific moment in time to be represented and reasoned. By extending Dey’s definition focusing on the interaction between the user and the system [7], Villegas et al. [8] proposes an operational definition: “Context is any information useful to characterize the state of individual entities and the relationships among them. This context information must be modeled in such a way that it can be preprocessed after its acquisition from the environment, classified according to the corresponding domain, handled to be provisioned based on the system’s requirements, and maintained to support its dynamic evolution”. This definition indicates that the relationship between context and dynamic evolution of system. Finkelstein et al. [9] concerns that context provides a manageable, easily manipulative description of the environment. Context has similarity and complementarily with uncertainty: (i) states are persistent changing in both context and uncertainty; (ii) context and uncertainty have the ability to model the environment between user and system; (iii) context and uncertainty have relation with changing requirement. Hence, these points offer the possibility of using context to represent uncertainty in SoSAS requirement. Context can be characterized as static and dynamic. Static context keeps the same state in all the time, such as birthday of passenger. Dynamic context can be highly variable, for example, the value of passenger’s location changes from one minute to the next. We here give a definition of context snapshot: A context snapshot is a dynamic context keeping the same state in a period of time. Definition 1(Context snapshot) a context snapshot is a tuple CS=(CF, P, V) where： CF is context factor which is a base construct for representing a group of entity as context knowledge; P is predicate; V is a quantitative value or a qualitative value. Some metaclasses is proposed in the metamodel of context snapshot [10]. Context factor includes ComputingFactor (such as bandwidth and devices), UserFactor (such as the user’s location and
88
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
calendars) and PhysicalFactor (such as location, time, traffic conditions, and temperature). The three main context factor categories mentioned in [11] could be viewed as context information for requirement modeling. State value is a conjunction of predicate and value. Profile is a set of context factors which have correlation. Policy rule is that several existing context snapshots educe a new context snapshot. The context snapshots appear in the same policy rule means having correlation and will be put in a profile.
2.2 Classification and representation of context snapshot The function of context snapshot in requirement model includes working as condition for goal refinement and trigger event for process realization. The description demand of condition could be classified context snapshot into three types: 1. Comparison: Comparing context factor and value. The context factor and value in this type of context snapshot could be measured by the same unit or be denoted by the same format. For example, “checkInDate” and “checkOutDate” are denoted by date format. 2. Verification: Verifying the relationship of context factor and value. The value should be verified as the attribute or class of the context factor. For example, “price P” as value is an attribute of “Proposal Pr” as context factor. 3. Operation: context factor making an operation with value. For example (S is a participant registered with negotiation N) The context snapshot is used as condition for goal refinement and traceability link, or precondition for process execution in requirement modeling. In context snapshot modeling, a rule markup language R2ML[12] is utilized to describe the context snapshot for three main reasons follows: first, the adaptation rule are reaction rules (ECA rules) that follow the event-condition-action model; second, the conditions part of the rule is a conjunction of atoms and the atoms can be express context snapshots; third, the triggering event part of the rule specify the core concepts required for dynamic behavior of rules and provides the infrastructure for more detailed definition of this behavior. Four atoms in R2ML can be used to represent the three types of context snapshot respectively, as shown in Table1. In different type of context snapshot, context factor and state value could be represented by different element. Table 1. Using R2ML atom to represent context snapshot Type
R2ML atom
Compariso n
DatatypePredicateAto m
Verificatio n Operation
Context factor
Predicate
Value
AttributeFunctionTer m
built-Ins for comparisons in SWRL
AttributeFunctionT erm |TypedLiteral
AttributionAtom
ObjectVariable
hidden “has”
DataVariable
ObjectClassificationAt om ReferencePropertyAto m
ObjectVariable
hidden “is”
Class
ObjectVariable
referenceProperty
ObjectVariable
Some elements in R2ML atom could be denoted with predefined classes with R2ML or ontology classes, such as classID and attributeID. In figure 1, the classID is denoted by predefined classes and the attributeID is denoted by predefined attributes in a vocabulary which can be R2ML own vocabulary. First part (lines 1–14) is a R2ML vocabulary which is a serialization of an UML fragment of class diagrams. In this vocabulary, a class “CheckAvailability” is defined and has two attributes “travelExpenditure” and “travelBudget”. Second part (lines 15-28) is a DatatypePredicateAtom modeling a comparison context snapshot “travel expenditure is less than travel budget”.
89
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
(a) DatatypePredicateAtom example (b) Condition example Figure 1. R2ML examples of Atom
4.
Driving uncertainty in contextual requirements
Context snapshot as uncertainty in modeling and evolution for SOSAS requirement includes three important functions. The first one is that the context snapshot will be used as refinement condition for user requirement modeling. The contexts snapshot as condition could be considered as extension basis of goal decomposition. The second one is that it will be utilized as trigger event for service requirement implement. The third one is constructing mean-context-end relation. In this section, context snapshot will be imported into goal-oriented customer requirements and process-oriented provider’s requirement to realize the three functions.
4.1Uncertainty in goal requirement Context snapshot as uncertainty point appeared in the goal-oriented customer requirement model. A subgoal in context decomposition requires a valid context snapshot as decomposition condition. Definition 2 (Context decomposition rule) If an entity or role of goal has system influence relation with a profile, then a relative context snapshots may play a role of decomposed condition. Definition 2 means if the context snapshots as condition hold then the sub goals need to be realized. The relative context snapshot means that the context factor in profile will construct context snapshot having relation with the decomposed goal. The context snapshot has direct and indirect function on context decomposition. The direct function is to play a role of condition in definition of context decomposition rule. For example, G34= (Generate route, Passenger, Generate, route, S(G34)) is a decomposed goal. “Passenger” as role of G34 has a profile {Time, TravelExpenditure}. The context factor “TravelExpenditure” has relative context snapshots “travel expenditure is less than travel budget” and “travel expenditure is greater than travel budget”. The former context snapshot is described with R2ML in figure 1(a). According to the operation and context decomposition rule, G34 is decomposed into G43 and G44. S(G34)={G43, G44}, G43= (Generate bus route, Passenger, Generate, BusRoute, S(G43)), G44= (Generate taxi route, Passenger, Generate, TaxiRoute, S(G44)). The context condition C2 “remain time is not enough” or “travel expenditure is less than travel budget” are described as in figure 1(b). The context condition C1 “remain time is enough” or “travel expenditure is greater than travel budget” are described similar with C2. In OR decomposition, the other context condition is usually contrary. The indirect function is to play a role of precondition of policy rule, in which the educed context snapshot will play the role of condition in definition of context decomposition rule. The policy rule could be described with Derivation Rules in R2ML.
4.2 Uncertainty in process requirement Context snapshot as uncertainty point appeared in the process-oriented provider’s requirement model. The points are precondition and effect of process. Comparing with triggering event as external condition, precondition as internal condition causes or has an impact on a process itself. Process execution requires a valid precondition, which means that capturing an obligation to perform the activity of process when the condition is true. Process execution may conduce an effect, which is the
90
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
result (i.e. product or outcome) of a process being executed by some cause or agent. The context snapshot could play the role precondition and effect. For example, the postcondition of P3 “taxi route is generated” is a context snapshot, which corresponds to a R2ML object classification atom. In R2ML, object classification atom usually is used to describe postcondition, which has same meaning with effect in process. The third one is constructing mean-context-end relation. If a traceability link is generated between a goal and a process and the goal is refined by context decomposition rule, then a MCE relation could be constructed from the supergoal and the process. It illuminates that the supergoal can be achieved via the process if and only if the condition holds.
5.
Support tool: ConUSER
5.1 ConUSER introduction In order to support the requirement editor and automatic analysis with ConUSER techniques, we have developed prototype automated reasoning and analysis tool called ConUSER support tool. The whole structure of tool has two parts: requirement editor and requirement analyzer, as shown in figure2. Requirement editor module includes requirement model editor and R2ML editor. Requirement model editor had developed to strive to facilitate the requirement model construction process. ConUSER play some pivotal roles in the process of requirement modeling. The first step is to derive context snapshots and policy rule. Context snapshot editor is a kernel part of R2ML editor. The output of context snapshot editor consists of all context vocabularies, context snapshots and policy rules. Context vocabularies are described with R2ML vocabularies and context snapshots are described with R2ML atoms. Policy rules are created in R2ML editor. The output content is stored in a native XML database. The second step is to derive goal and process from user requirements. The requirements could be described by customer with a structure nature language SORL [13]. SORL-based requirement elicitation approach enables common stakeholders to write requirements and employs semantic inducement to make correct, complete and consistent requirements. And then the SORL requirements could be translated into goals and processes [14]. The third step is to construct goal-based requestors’ requirement model and process-oriented provider’s requirement model, which are refined and generated semi-automatically in requirement analyzer of ConUSER. The requestors’ and provider’s requirement model are constructed with a popular ontology language OWL. According to the three decomposition rules, goal refinement could be automatic via semantic inference with the assistant of domain-specific and context-specific knowledge model in goal refinement analyzer. And then, a process workflow is generated according to three widthways dependency relations proposed in [15].
Reused goal‐ process set
Domain model
Context snapshot model editor
Context snapshot model
Goal refinement analyzer
Means‐context‐ends analyzer
R2ML editor
Requirement editor
Data support
Model input/output
Requirement analyzer
Requirement model editor
initial goal set
Language translator
goal‐process base requirement model
Figure2. Structure of ConUSER The last step is to analyze means-c-end. According to overlap rule and satisfaction rule, traceability link is constructed between goal and process. Means-c-end could be generated automatic in means-
91
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
context-ends analyzer. The context snapshot represented with R2ML could be translated into OWL. The output of requirement analyzer in ConUSER is an OWL file, which represents the context-based requirement model.
5.2 Evaluation For measuring the effect of context in requirement elicitation and analysis, three types of requirements in house of quality are imported. Revealed requirements describe what we get by asking customers what they want; exciting requirements usually are difficult to discover and are beyond the stakeholders’ expectation, but this kind of requirement will improve the satisfaction degree of users availably; expected requirements are often difficult to discover or customers may fail to mention until software is performed in real environment. Two metrics are defined in this paper: rate of exciting requirements (ERI) and rate of expected requirements (ERII). ERI is the proportion of number of expected requirements to number of revealed requirements and expected requirements, can be defined ExcitingRSet (1) ERI RevealedRSet ExcitingRSet
The initial goal set is the “RevealedRSet”. The set of goals which are obtained for operation and entity decomposition rule is “ExcitingRSet”. ERII is the proportion of the number of exciting requirements to the number of revealed requirements and exciting requirements, can be denoted as ExpectedRSet (2) ERII RevealedRSet ExpectedRSet
The set of goals which are obtains for context decomposition rule and processes having means-cends relation with goals are “ExpectedRSet”. ConUSER tool has been installed on a computer equipped with an Intel Pentium IV 3.00GHz with 1GB RAM, 80G hard disk and running Microsoft Windows XP. Together with the three domain experts, we experimented with ConUSER approach in city intelligent traffic domain. The three domain experts construct three scenarios and the detail data is shown in Table2. Because of the concepts of domain ontology in scenarios (iii) is obtained insufficiently, the other data are less than ones in scenarios (ii) and scenarios (ii). Table 2. The model size in three scenarios of city intelligent traffic domain Scenarios
Domain ontology size
Initial goal model size
Process model size
Context snapshot model size NSP
NC
NR
NA
NDG
NP
i
169
33
9
16
47
19
ii
181
37
9
14
44
18
iii
89
30
8
9
22
10
NC: number of concept NR: number of relation NA: number of actor
NDG: number of decomposable goal NP: number of process NCS: number of context snapshot
After running ConUSER in the three scenarios, we tested its scalability on domain ontology of different size. Figure 3 depicts the results: the x-axis represents the number of domain concepts, the yaxis represents the results of ERI in (a) and the results of ERII in (b). The collected data on one side show that the exciting requirements are growing exponentially with the increase of the domain ontology size, on the other side show that the exciting requirements obtained with sufficient domain knowledge sizes are more than that obtained with insufficient one.
92
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
100%
100%
90%
scenarios(i)
90%
scenarios(i)
80%
scenarios(ii)
80%
scenarios(ii)
70%
scenarios(iii)
70%
scenarios(iii)
60% ERII
ERI
60% 50%
50%
40%
40%
30%
30%
20%
20%
10%
10%
0%
0% 0
50 100 150 Number of domain concepts (a)
200
0
50 100 150 Number of domain concepts (b)
200
Figure 3．The result of ERI and ERII in city intelligent traffic scenarios
6.
Related work
Recently, there has been a surge of interest in requirement engineering research for self-adaptive systems. Berry et al. [16] proposed a four level framework of requirement engineering for dynamic adaptive systems(DAS). Goldsby et al. [17] proposed a LoREM approach to modeling the requirements of a DAS using i* goal models at the four level. Baresi et al. [18] propose FLAGS based on the KAOS framework to specify the requirements and adaptation capabilities of self-adaptive systems. Some approaches aim to capture uncertainty in requirement. Whittle et al. [5] introduce a structured natural language requirements specification RELAX for self-adaptive systems that explicitly addresses uncertainty. Souza et al. [19] propose awareness requirements for adaptive systems to realize the function like RELAX. The AwReqs are represented as goal and expressed in OCLTM for imposing constraints on the run-time behavior in requirements. Several approaches focus on the context representation and reasoning. Some context language and model is special for requirement. Robinson et al. [20] describe the Context Modeling Language (CML) which can be used to capture context information requirements to be used in the design of contextaware applications. Fuchs et al. [21] propose a modeling technique for context information based on metamodeling which considers the requirements posed on it by the nature of context information and the development of context-aware systems. Other context representation approaches could be used in requirement model. Chen et al. [22] propose context ontology (SOUPA) that can be used to exchange context among entities in a uniform manner. Ma et al.[23] propose a context prediction scheme by set pair analysis (SPA) method to improving the accuracy of predicted context. Ye et al.[24] propose a formal context representation model in which a user's context is described by a set of roles and relations correspond to a context space. We review related work to contextualized requirement models according to two categories: contextaware goal modeling and context-aware process modeling. Ali et al. [25] use the notion of context to express domain variability in goal model. Dalpiaz et al. [26] also use context-enriched goal models, aiming to deploy adaptive systems. Besides constraining the selection of alternatives, the context is used to define activation events and commitment conditions for goals and preconditions to tasks. The approaches mentioned above are both using i* models to produce requirement models, and representing contexts with natural language and reasoning them in assertion-level logic. Rosemann et al. [27] propose that context can be defined as the set of environmental properties that have an impact on process design and/or execution. La Vara et al. [28] provided a mechanisms and detailed guidance for correct modeling of business processes that fit their context and thus are properly executed in all the context variants of their business environment.
7.
Conclusion and future work
In this paper, we present a context snapshot fusion framework for modeling and analysis requirements of service oriented self-adaptive software. Our main contributions include an approach on representing uncertainty in self-adaptive software requirement as context snapshot which is described
93
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
with R2ML atoms. In terms of performance, we have applied our approach on a scenario of a mobile information system of city transportation in ConUSER support tool. As future work, we will work to enrich our context snapshot representation and analysis to deal with the imperfect context snapshot. The context snapshot may be incorrect if it fails to reflect the true state of the world it models, inconsistent if it contains contradictory information, or incomplete if some aspects of the context snapshot are not known. We expect to enhance the scalability of ConUSER support tool and reduce the amount of effort an analyst is required to pay in order to construct our proposed model and use our analysis techniques. The study of self-adaptive evolution mechanism in the requirement model proposed in this paper is our next plan.
8.
Acknowledgments
This research project was supported by the National Natural Science Foundation of China (Grant No. 60873024), the Natural Science Foundation of Hubei Province (Grant No. 2010CDB08503), Open Foundation of SKLSE (Grant No. SKLSE-2010-08-25) and Doctor foundation for Science Study Program of Wit (Grant No.12096022).
9.
References
[1] P. K. McKinley, S. M. Sadjadi, E. P. Kasten, and B. H. C. Cheng, “Composing Adaptive Software” , IEEE Computer, vol. 37, no. 7, pp. 56-64, 2004. [2] D. Fabiano, “Exploiting Contextual and Social Variability for Software Adaptation”, PhD thesis, University of Trento, 2011. [3] A. Antón, “Goal-Based Requirements Analysis”, In Proceedings of the 2nd International Conference on RequirementsEngineering, IEEE Computer Society Press, Los Alamitos, CA, pp. 135-144, 1996. [4] C. Ebert and J. D. Man, “Requirements Uncertainty: Influencing Factors and Concrete Improvements”, In Proceedings of the International Conference on Software Engineering, pp. 553-560, 2005. [5] C. B. de Lemos and R. G. Hoger, “RELAX a Language to Address Uncertainty in Self-Adaptive”, Software Engineering for Self-Adaptive Systems, Vol. 5525, Springer, pp.1-26, 2009. [6] D. L. Parnas, “Designing Software for Ease of Extension and Contraction”, IEEE Trans. On Software Engineering, Vol.5, No.2, 1979. [7] G.D. Abowd, A.K. Dey, P.J. Brown, N. Davies and M. Smith, “Towards a Better Understanding of Context and Context-awareness”, Gellersen, H.-W. (ed.) HUC LNCS, vol. 1707, pp. 304-307, 1999. [8] N.M. Villegas and H. A. Müller, “Managing Dynamic Context to Optimize Smart Interactions and Services”, The Smart Internet Lecture Notes in Computer Science, Volume 6400/2010, pp.289318, 2010. [9] A. Finkelstein and A. Savigni, “A Framework for Requirements Engineering for context-aware services”, In Proceedings of STRAW 01 the First International Workshop From Software Requirements to Architectures, 2001. [10] W. Liu, C.W. He and Z.W. Feng, “Requirement Uncertainty Modeling for Service oriented Selfadaptive Software”. Advanced Materials Research, v.433-440, Materials Science and Information Technology, pp.4798-4801, 2012. [11] H. Dan and D.K.W. Chiu, “Requirements elicitation for the design of context-aware applications in a ubiquitous environment”, In Proc. of the 7th International Conference on E-Commerce (ICEC 2005), 2005. [12] G. Wagner, et al, “R2ML: A General Approach for Marking up Rules”, Dagstuhl Seminar Proceedings 05371, F. Bry, F. Fages, M. Marchiori, H. Ohlbach (Eds.) Principles and Practices of Semantic Web Reasoning, 2005. [13] W. Liu, K.Q. He, J. Wang, et al, “Heavyweight semantic inducement for requirement elicitation and analysis”, In Proceedings of Third International Conference on Semantics, Knowledge and Grid, pp. 206-211, 2007. [14] W. Liu, “Research on Services-oriented Software Requirements Elicitation and Analysis”. Ph.D. thesis, Wuhan University, 2008.
94
Uncertainty Modeling of Self-adaptive Software Requirement Wei Liu, Zaiwen Feng
[15] W. Liu, C.W. He and K. Zhang, “Domain Component-based Service Requirements Modeling and Analysis”. In Proceedings of the IEEE International Conference on Computational Intelligence and Software Engineering, Wuhan, China, pp.1-5, 2009. [16] D. Berry, B. Cheng, and J. Zhang. “The four levels of requirements engineering for and in dynamic adaptive systems”, In Proceedings of the 11th International Workshop on Requirements Engineering: Foundation for Software Quality, Porto, Portugal, 2005. [17] H.J. Goldsby, P.Sawyer, N.Bencomo, et al. “Goal-based modeling of dynamically adaptive system requirements”, In Proceedings of 15th Annual IEEE Iternational Conference on the Engineering of Computer Based Systems, 2008. [18] L. Baresi, L. Pasquale, P. Spoletini, “Fuzzy Goals for Requirements-driven Adaptation”, In Proceedings of 18th International IEEE Requirements Engineering Conference, RE'10, Sydney, Australia, 2010. [19] S. Souza, V. E. L. Alexei and N. William, “Awareness Requirements for Adaptive Systems”, In Proceedings of the 6th International Symposium on Software Engineering for Adaptive and SelfManaging Systems. 2011. [20] R. Robinson, K. Henricksen, “XCML: A runtime representation for the Context Modelling Language” , In Proceedings of Pervasive Computing, 2007. [21] F. Fuchs, I.Hochstatter, M. Krause and M. Berger, “A Metamodel Approach to Context Information”, In Proceedings of Third IEEE International Conference on Pervasive Computing and Communications Workshops, 2005. [22] H. Chen, T. Finin, and A. Joshi, “The SOUPA Ontology for Pervasive Computing. Ontologies for Agents: Theory and Experiences”. Ontologies for Agents: Theory and Experiences, 2005. [23] Ma Shou-ming, Wang Ru-chuan, Ye Ning , "Using Context Prediction for Elderly Health Monitoring in Pervasive Computing Environments ", JDCTA: International Journal of Digital Content Technology and its Applications, Vol. 5, No. 1, pp. 16-25, 2011. [24] Ye Ning, , Wang Ru-chuan, ,Ma Shou-ming ,Wang Zhi-li , "Fuzzy Logic Based Middleware Approach for Context Processing", JDCTA: International Journal of Digital Content Technology and its Applications, Vol. 3, No. 3, pp. 42-46, 2009 [25] R. Ali, F. Dalpiaz and P. Giorgini, “A Goal-based Framework for Contextual Requirements Modeling and Analysis”, Journal of Requirements Engineering, Volume 15, Number 4, pp.439458, 2010. [26] F. Dalpiaz, P Giorgini, J Mylopoulos, “An Architecture for Requirements-driven SelfReconfiguration”, Adv Inf Syst EngLNCS 5565, pp.246-260, 2009. [27] M. Rosemann, J. Recker, C. Flender, “Contextualisation of Business Processes”. International Journal of Business Process Integration and Management 3(1), pp.47-60, 2008. [28] José Luis de la Vara, Raian Ali, Fabiano Dalpiaz, et al, “Business Processes Contextualisation via Context Analysis” , In Proceedings of the International Conference on Requirement Engineering, pp.471-476, 2010.
95
