Self-Adaptive Applications: On The Development OfPersonalized Web-Tasking Systems

Lorena Castañeda*†‡

*University of Victoria, Canada†IBM Canada Software

Laboratory, CAS ResearchMarkham, Canada

‡Icesi University, Colombialcastane@uvic.ca

Norha M. Villegas‡

‡Icesi University, Colombianvillega@icesi.edu.co

Hausi A. Müller*†*University of Victoria, Canada

†IBM Canada SoftwareLaboratory, CAS Research

Markham, Canadahausi@uvic.ca

ABSTRACTPersonalized Web-Tasking (PWT) proposes the automationof user-centric and repetitive web interactions to assist usersin the fulfilment of personal goals using internet systems.In PWT, both personal goals and internet systems are af-fected by unpredictable changes in user preferences, situa-tions, system infrastructures and environments. Therefore,self-adaptation enhanced with dynamic context monitoringis required to guarantee the effectiveness of PWT systemsthat, despite context uncertainty, must guarantee the ac-complishment of personal goals and deliver pleasant userexperiences. This paper describes our approach to the de-velopment of PWT systems, which relies on self-adaptationand its enabling technologies. In particular, it presents ourruntime modelling approach that is comprised of our PWTOntology and Goal-oriented Context-sensitive web-tasking(GCT) models, and the way we exploit previous SEAMScontributions developed in our research group, the DYNAM-ICO reference model and the SmarterContext Monitor-ing Infrastructure and Reasoning Engine. The main goalof this paper is to demonstrate how the most crucial chal-lenges in the engineering of PWT systems can be addressedby implementing them as self-adaptive software.

Categories and Subject DescriptorsD.2 [Software Engineering]: Design, Software Architec-tures—Representation, Domain-specific architectures

General TermsSoftware Engineering

KeywordsUser-Centric, Personalized Web-Tasking, Runtime Models,Self-Adaptive Systems, Context-Awareness, Situation-Awareness

Permission to make digital or hard copies of all or part of this work forpersonal or classroom use is granted without fee provided that copies arenot made or distributed for profit or commercial advantage and that copiesbear this notice and the full citation on the first page. To copy otherwise, torepublish, to post on servers or to redistribute to lists, requires prior specificpermission and/or a fee.Copyright 20XX ACM X-XXXXX-XX-X/XX/XX ...$15.00.

1. INTRODUCTIONUsers rely on the internet to perform ordinary and repet-

itive tasks, and feel more comfortable when web systemsprovide high levels of personalization and automation. De-spite the existence of applications to automate and person-alize web interactions, these are insufficient to guarantee theaccomplishment of user goals when changes in relevant con-text cannot be fully anticipated at design time. PersonalizedWeb-Tasking (PWT) is defined as the automation of repet-itive web interactions that, together with the exploitationof personal context (e.g., information from personal profiles,social relationships, and historical web interactions), seeksto optimize user experiences by assisting people in the ful-filment of personal goals using internet technologies [2, 4].

Managing web interactions at runtime is a complex task.A first cause of this complexity is that internet infrastruc-tures experience frequent and dynamic updates, as well asadditions or removals of numerous devices, applications, com-munication protocols and services. A second cause is thatthe situations and preferences of users may change whileperforming web interactions. In regular web interactions,dealing with this complexity implies for the user to be awareof changes that may affect the accomplishment of personalgoals to adjust web tasks accordingly. For example, by in-stalling updates, consuming new services, learning aboutnew applications, accessing web services from different de-vices, or creating multiple profiles. Under these circum-stances, the effectiveness of web interactions to accomplishpersonal goals is limited by the level of expertise of the userto interact with specific technologies, thus compromising notonly user experiences but also the value that businesses canobtain from internet technologies.

The success of PWT relies on the capability of internetinfrastructures and web applications to free users from themanagement of these complexities. Therefore, PWT soft-ware systems must be capable of understanding user needs,act upon changes in relevant contexts, and recognize users ascentral controllers of web interactions to assist them in per-forming web-tasks with a minimum of effort, while maximiz-ing their satisfaction. For this, PWT applications must bedesigned and implemented as software systems that exposeself-* properties [6, 8, 7], and support situation-awareness [3,9]. They must be self-configurable for dealing with dynamiccontext changes by adjusting their behaviour or structureat runtime. In particular, they must expose self-healing and

self-optimizing capabilities to ensure the accomplishment ofuser goals in the presence of system failures, and guaran-tee pleasant user experiences under changing environments,user goals and situations.

To implement PWT applications as self-adaptive software(SAS) systems we propose a set of runtime models that al-low us to represent user goals, system concepts and contextentities as artefacts that maintain a causal connection andthat can be manipulated while the system is running. Todesign and implement the PWT system presented in thispaper, we used the DYNAMICO reference model proposedby Villegas et al. [10]. DYNAMICO supports the implemen-tation of SAS systems that are highly affected by changesin goals and context situations at runtime. SAS systems de-rived from DYNAMICO implement three subsystems thatmight be in turn self-adaptive: (i) the control objectivessubsystem maintains the relevance of the PWT system withrespect to changes in the user’s personal goals; (ii) the adap-tation mechanism allows the system to act upon changesthat occur either in the context or in the requirements ofthe system; (iii)the monitoring infrastructure keeps track ofcontext events that are relevant to the execution of task se-quences.

Monitoring mechanisms in our PWT system are providedby the SmarterContext monitoring infrastructure [11] andits ontologies, which we extended with our PWT ontology.Indeed, our extension instruments the SmarterContextReasoning Engine (SCoRE) with basic capabilities requiredto infer, from personal context information, knowledge valu-able to optimize future PWT executions. For example, byrecommending other web services or a different web task se-quence based on the similarity of the user with others (e.g.,taking into account the user’s gender, age, location, andpreferences).

This paper presents our vision on the implementation ofPWT systems as SAS systems. Besides the DYNAMICOreference model and the SmarterContext infrastructure,the self-adaptive capabilities of our PWT implementationare supported by two runtime models presented in this pa-per: (1) our personalized web-tasking (PWT) model, an on-tology that defines the concepts and artefacts of personal-ized web tasking; and (2) our goal-oriented context-sensitiveweb-tasking (GCT) model, a representation of the evolvingweb-tasking goals and web interactions of a user, as well asthe relevant context that may affect the successful executionof the tasks.

The remaining sections of this paper are organized as fol-lows: Section 2 describes an online grocery shopping appli-cation scenario that we use to illustrate the PWT domain.Section 3 presents our runtime models and the implementa-tion of our PWT system. Finally, Section 4 discusses chal-lenges, and Section 5 concludes the paper.

2. AN ONLINE GROCERY SHOPPINGSCENARIO

We selected online grocery shopping as the personal goalfor our case study because its activities are repetitive, per-formed periodically, and can involve social interactions (e.g.,relatives, friends, and other users). Moreover, the fulfilmentof grocery shopping goals requires a variety of services anddifferent internet data sources.

In regular grocery shopping scenarios (i.e., those not sup-

ported by PWT systems), we identify four main web inter-actions that are manually executed by the user:

(1) The user gets the shopping list which implies to log intoher preferred grocery list service using a web browser ora mobile application.

(2) The user locates the proper stores using geo-localizationservices to find nearby grocery stores that she will filtermanually according to her preferences that are alreadyavailable in her social network.

(3) The user creates independent shopping lists by matchingboth items and stores according to different criteria. Forinstance, the category best deals of the season, whichimplies to compare prices manually to select the bestoffer according to her budget, or best reviews for bothproducts and stores.

(4) The user proceeds with the purchase selecting one oftwo possible ways: if the store provides an online pur-chase service the user can proceed with the payment andschedule the delivery; otherwise she will have to man-ually plan the grocery shopping visit while taking intoaccount different conditions that can affect the pick-upprocess such as time, traffic, and the store’s shoppinghours.

Online grocery shopping requires PWT systems for opti-mizing user experience and increasing revenue generation.This is because shopping web-tasking is exposed to uncer-tainty generated by the interoperation among different webservices (e.g., changes in service compositions, incompati-bility of data), and the changes in the user’s context (e.g.,location, preferences, special events, or her behavior whenbrowsing the internet). Online grocery shopping activitiesare also affected by social context, that is, the informationgathered from other people within the user’s social sphere(e.g., friends, relatives, and colleagues). By effectively com-bining these context dimensions, it is possible to adjust thePWT sequence with the goal of achieving the goal accord-ing to the actual user situation or concerns. For example, abirthday party event in the user’s calendar will update theshopping list with new items that are required only for thisparticular event, and might also imply the rescheduling oftask’s execution time. Similarly, based on the rankings thatother users provide to services, the PWT system may sug-gest for example a better service to obtain discount coupons.The user could decide to include this new service into hertask sequence to optimize the accomplishment of her shop-ping goal.

Having no PWT support to cope with these changes thatmight affect the achievement of personal goals, the user mustadapt the set of required web interactions manually thushampering the quality of the user’s experience.

3. OUR PWT SOFTWARE SYSTEMThe realization of PWT requires the implementation of

SAS systems to support as much automation and personal-ization as possible in all aspects of the user’s web-tasking.We posit that the design and implementation of PWT sys-tems must be driven by the following requirements:

(1) Personal goal identification: The system must under-stand the user’s personal goal in machine readable lan-guage that can be processed at runtime.

(2) Web-task sequencing: The system must define orderedsequences of web-subtasks required to achieve a personalgoal, including the specification of dependencies, ser-vices, inputs and outputs.

(3) Web-task personalization: The system must exploit con-text information to define the web-task sequence to beexecuted. This context information can be a user’s per-sonal context [11], historical web-interactions, other usersin her social network, and all relevant context from theenvironment.

(4) Web-task execution: The system must execute the se-lected web-task sequence while performing managementactivities such as life cycle control, conflict resolution,and fault recovery.

(5) Context-awareness and self-adaptive support: The sys-tem must act upon unexpected context changes by adapt-ing itself at runtime, when applicable.

3.1 Runtime Models for Realizing PWTTo guarantee dynamism and flexibility in PWT, we re-

quire models that can be manipulated and adapted dur-ing the execution of the system [1]. We have categorizedmodelling requirements for PWT systems into three con-cerns: user personal goals, web-task sequences, and context.Moreover, we surveyed different modelling approaches, inparticular goal-oriented modelling, ontologies, task modelsand workflows, with the purpose of identifying the most ap-propriate models for our problem. As a result of this com-parative study, we proposed two approaches that cover allthe modelling requirements that we identified for PWT sys-tems: (1) Our personalized web-tasking (PWT) model, and(2) our goal-oriented context-sensitive web-tasking (GCT)model.

PersonalGoal

WebTaskSequence

WebSubtask

ObservableResult

SatisfactionProperty

Input

InformationResource

Activity

PlanItem

int

orderNo

hasWebTask [1]

definedBy [1…*]

measuredBy [1…*]

achievedThrough [1]

executionPlan [1…*]

hasPredecessor [0…*]

hasResult [1…*]

connectsTo [1…*]

performs [1…*]

hasParameters [0…*]

obtained [1]

Condition

constrains [0…*]

executionPolicies [0…*]

Output

is-a

Figure 1: Simplified view of our PWT ontology model

The PWT ontology model depicted in Figure 1, is basemodel and an ontology that defines the concepts of person-alized web tasking: personal goal, web-task sequence, exe-cution plan, activitites, information resources, inputs, con-ditions, and satisfaction properties. Our PWT ontology isavailable as a runtime model in the form of an OWL2/RDFfile.1 Moreover, our ontology is applicable in different do-mains (i.e., tasking supported by stand-alone software sys-tems), and can be extended according to the evolution ofthe web.1http://www.rigiresearch.com/research/pwt/pwtOntology.owl

GS-PWTSystem

Empty GS list

Keep budget

Query user’s GS list items

Find proper stores

Purchase items

Connect GS list app

GS List App

GS Store App

Online Payments

App

WebService information

WebService information

WebService informationConnect GS

store app

Connect OP app

List Items

Update List

Store Catalogue

Credit Card Charges

Match list with catalogue

Create GS sublists per Store

Proceed with checkout

Store Shopping Cart

PWT Grocery Shopping

Purchase items per store

Asses credit card charges

t1

t2

t3

t4

t5

t6

t8

t9

t11

t12

t7

t10

Actor

Goal

Task

#

Resource

PWT System, External Application (web services)

Conventions: i* to PWT

User’s personal goal, observable results

Web-subtasks

Web-task sequence number

Information Resources

Figure 2: Goal-oriented Context-sensitive web-tasking(GCT) model expressed using the i* Framework [5].

Our GCT model is an extension and redefinition of theiStar Framework [5] proposed by Horkoff et al. This modelsupports the specification of evolving web-tasking goals, per-sonal web interactions, and the relevant contexts. In partic-ular, we extended the iStar atomic notions of actor, goals,task and resources, to support the specification of web-taskinggoals, task sequences, tasks and subtasks, as well as the re-lationships among tasks, subtasks and resources. Figure 2depicts an example of the GCT model for the online groceryshopping scenario described in this paper.

To demonstrate the practical feasibility of our modellingapproach, we implemented a prototype of our PWT run-time models for the grocery shopping scenario. We usedApache JENA—an open source Java framework for build-ing semantic web and linked data applications,2 to createthe runtime models required in our online grocery shoppingscenario.3 Each RDF graph constitutes a runtime instanti-ation of a user’s web-tasking. These graphs are processedby our PWT System to execute the web-tasking on behalfof the user.

3.2 Components of our PWT SystemOur PWT system comprises the following main software

modules:

2http://jena.apache.org/

3http://www.rigiresearch.com/research/pwt/GroceryShopping.rdf

(1) Web-Tasking Knowledge Infrastructure: provides the in-strumentation to express user personal goals (i.e. thecontrol objectives of the PWT system—the upper layerin DYNAMICO) in the form of a GCT model. Thecomponents in this module perform two main activities:(i) record information from a user’s web interactions,and (ii) represent this information in the form of a GCTmodel instance (cf. Figure 2). To record a user’s web in-teractions we need to identify, interpret and characterizeweb actions (e.g., click, selection, or inputs) and data,which implies instrumenting the browser, devices andweb sites to extract this information. Finally, the sys-tem translates the information gathered from the user’sweb interactions into a GCT model.

(2) PWT Model Processor: processes our PWT models togenerate the corresponding RDF graphs (GCT models)that specify all the information about the user web-tasking, which includes web-task sequences, web ser-vices, inputs, and satisfaction metrics. The PWT ModelProcessor might determine that for one personal goalthere are several RDF graph candidates based on theuser’s historical behaviour. In this case, these candi-dates are sent to the next module of the system; thePersonalization Engine will select the proper web-tasksequence to be executed.

(3) Personalization Engine: selects the proper RDF graphbased on personal context information provided by theSmarterContext Reasoning Engine (SCoRE) [11]. Thiscontext information is relevant for its particular goal,and can be either static (e.g., age, or gender) or dynamic(e.g., location, preferences, or social information). Theresult is one single RDF graph.

(4) Web-Tasking Effector: executes a sequence of web in-teractions on behalf of the user, and at the same timeacts as a controller of the system by preforming the fol-lowing activities: web-task life cycle control (i.e., thestart and end of the web-task), web services invocation(i.e., communication protocol and data exchange), userinteraction requests (i.e., tasks that can not be fully au-tomated), conflict resolution (e.g., service unavailability,or data type incompatibility), and a final assessmentto guarantee the fulfilment of the personal goal. OurWeb-Tasking Effector supports three levels of automa-tion: manual (i.e., the user explicitly specifies which webinteractions correspond to a particular personal goal),assisted by recommendations (i.e., the system suggestsweb interactions to the user), and fully automated (i.e.,the system executes web interactions on behalf of theuser).

3.3 Realizing Self-Adaptation in ourPWT System

As a reference model, DYNAMICO provides software en-gineers with a characterization of the structure and behaviourof the minimal set of components required to implementcontext-driven SAS systems. This model defines three feed-back loop subsystems causally connected as depicted in Fig-ure 3: control objectives manager (CO-FL), adaptation con-troller mechanism (A-FL), and monitoring infrastructure(M-FL). We designed our PWT system using the DYNAM-ICO reference model.

Reference Control

Objectives (e.g., SLAs)

(D)

Sensed

Context

Information

Objectives Feedback Loop

Adaptation Feedback Loop

Monitoring Feedback Loop

(A)(B) (C)

Control/data !ow

Legend:

Feedback loop abstractionCO-FL

A-FL

M-FL

Figure 3: DYNAMICO reference model for context-drivenself-adaptive software systems [10]

Figure 4 presents of our runtime models and PWT sys-tem’s modules mapped onto the layers of DYNAMICO. Theupper level corresponds to the Web-Tasking Knowledge In-frastructure that receives the user’s personal goals, the con-trol objectives of DYNAMICO. This level keeps track ofchanges in the user’s goals to trigger the adaptation of thePWT system (second level) and/or the monitoring infras-tructure (third level). The main objective of the Web-TaskingKnowledge Infrastructure is to guarantee that the PWT sys-tem is really the one that will allow the user to accomplishher personal goals. The middle level comprises the adap-tation mechanism and the target system. The latter corre-sponds to our PWT Model Processor, Personalization En-gine, and Web-tasking Effector. Our PWT system exposesbehavioral and structural adaptation. With respect to be-havioral adaptation, our system supports the modificationof existing algorithm or the injection of a new algorithmto process newer versions of the GCT model. Regardingstructural adaptation, our system supports the reconfigura-tion of its architecture according to different grid-computingtopologies, in particular to optimize the execution of paral-lel web-tasks. The lower level of DYNAMICO correspondsto the SmarterContext infrastructure, which enables ourPWT system with dynamic context-aware capabilities. Fi-nally, our runtime models are required across all the DY-NAMICO levels of our PWT system. This is expected sincethe system must maintain a causal connection not only be-tween these models, but also between them and the systemimplementation.

3.3.1 Context-Awareness SupportBy extending the SmarterContext ontology to be used

in the Personalized Web-Tasking domain, we instrumentedthe SmarterContext monitoring infrastructure to identifyand understand relevant context that is required during theexecution of our PWT system. Instances of context entitiesand information relevant to PWT systems include: (i) ex-ternal context such as other systems that interact with thePWT system during the web-tasking execution. For exam-ple, in our shopping scenario, external context can be thegrocery store web services used to retrieve information fromproduct catalogues; (ii) internal context that includes allthe elements within the system, the communication chan-nels among them and any information about the executionof the system. For instance, the information exchanged be-

Adaptation Mechanism

Control Objectives Manager

Target System

Web-tasking Knowledge Infrastructure

PWT Model Processor

Personalization Engine

Web-Tasking Effector

1

2 3 4

Monitoring Infrastructure

Personal goals

SmarterContext Monitoring Infrastructure

Ru

ntim

e mo

dels

Figure 4: Mapping our runtime models and system modulesonto the DYNAMICO reference model.

tween two web-tasks that are sequenced, and the life cyclecontroller; (iii) domain-related context that affects the wayusers interact with the web to achieve a personal goal. Forexample, web technologies and devices, correlation amongweb applications; finally, (iv) user context, that includes notonly personal information (e.g., location), but also social in-formation (e.g., food preferences of the family members thatlive with the user). Personal context includes also the webbehaviour of the user, for example, the way of interactingwith a new service, the frequent addition or removal of steps(web interactions) to standard executions, or the modifica-tion of input information.

3.3.2 Levels of Self-AdaptationIn our PWT system, self-adaptation occurs at two lev-

els: (1) the runtime models, and (2) the PWT system com-ponents. Adaptation in the runtime models are triggeredby changes in the PWT problem domain that affect theuser’s web-tasking behaviour (e.g., technologies used to ex-ecute grocery shopping). The second level corresponds tobehavioural or structural adaptations in the PWT systemtriggered by context changes. Certainly, the modificationsin the runtime models (first level) necessarily imply adap-tations in the PWT system (second level) required for itto understand, instantiate, and execute the PWT modelsproperly.

As an illustration, let us assume that the user scans withher mobile phone a QR code found in the product labels.These labels contain detailed information such as type ofproducer (e.g., organic, industrial, artisan, or imported),and transportation (e.g., type of vehicle, transport condi-tions, or original and passing locations). Figure 5a shows asequence diagram of the PWT system activities to performself-adaptation, described as follows: (1) By scanning theQR code in the products, the user notifies the system thata change in the context domain had occurred (i.e., a newuser interaction). This event is sensed by the MI and it isclassified as relevant, given that the interactions with prod-ucts is a concern in the grocery shopping personal goal ofthe user (2) The MI reports the relevant event to the AMwho decides that the current representation of the domain(cf. Figure 2) does not include information to understand

RMAMMI COC

(1) (2) (3)

(4)(5) (6)

(7)

TS

(a) Change in the PWT domain.

RMAMMI COC

(1) (2) (3)

TS

(b) Change in the personal context of the user.

Figure 5: Self-adaptation sequence diagram for a changein the context. Legend: C: Context, MI: Monitoring In-frastructure, AM: Adaptation Mechanism, RM: RuntimeModels,CO: Control Objectives, and TS: Target system.

and process those QR codes. (3) As a result, the AM effectsthe corresponding adaptations over the RM to update thePWT models with this new source of information relevantfor the web-tasking of the user. (4) Moreover, the MI no-tices a new version in the runtime models that jeopardizesthe proper execution of the PWT System. Naturally, (5) theMI reports the event to the AM, who in response adaptsboth (6) the CO (specifically the Web-Tasking KnowledgeInfrastructure) to understand this new information and gen-erate the proper GCT model realizations (RDF Graph), and(7) the TS to process, personalize, and execute the RDFGraph accordingly.

It is worth mentioning that not all the adaptations in thesecond level (i.e., the PWT system components) are gener-ated by changes in the runtime models. In our approachthe MI is aware of all the relevant contexts. For example,let us assume that the user travels to another city for twomonths. Figure 5b depicts the following sequence of activ-ities: (1) The MI realizes that the user has changed herlocation and (2) reports the event to the AM. In response,the AM (3) effects the corresponding adaptations in the TS,more specifically in the Personalization Engine to includethe new location of the user as an important element forpersonalizing the web-tasking. In this case, the adaptationwas not triggered by changes in the models or the controlobjectives.

The separation of concerns introduced by DYNAMICOallows us to address the variety of design and implementa-tion concerns inherent in PWT applications. In particular, itfacilitates the management of the dynamic nature of goals,models, and systems separately, while maintaining the re-quired causal connections among them.

4. DISCUSSIONWe presented our approach to the realization of PWT ap-

plications as SAS systems. First, we presented our runtimemodelling approaches (PWT Ontology, and GCT models)which support the implementation of dynamic, flexible andself-adaptive PWT systems. In addition, we demonstratedits practical feasibility by implementing RDF graphs thatmake our GCT models available at runtime, and by describ-ing the software modules of our PWT system. Our approach

to implement PWT systems as adaptive software exploit pre-vious SEAMS contributions, in particular the DYNAMICOreference model [10], and the SmarterContext monitoringinfrastructure and reasoning engine [11].

In this section we discuss two challenges that are crucialfor the improvement of self-adaptive capabilities in PWTsystems: (1) web instrumentation, and (2) social context.

Web Instrumentation. Current web applications are notfully instrumented to be recorded, characterized, and mod-elled by third party applications as required by PWT sys-tems. There are some approaches to record and replay webinteractions (e.g., ClickTale4, Selenium5, Solex6, or Mouse-flow7). However, they are mostly limited to register useractions (i.e., click, selection, browsing) and inputs (e.g., theautofill mode of the browsers). Moreover, these approachesare not designed to respond to unpredictable context changes,nor to understand how a user’s changing personal goals af-fect web interactions. We posit that the implementationof dynamic web environments (i.e., applications, browsers,and devices) that enable PWT systems to acquire contex-tual details from the user’s web experience, and to adaptweb interactions accordingly, is a major web instrumentationchallenge in the self-adaptation realm. Web instrumenta-tion implies the development of self-adaptation middlewaresto address the complexity raised by the dynamic nature ofuser web interactions.

Social context. We define social context as all the informa-tion gathered from the social relationships (whether virtualor real) of the user and that is relevant to a personal web-tasking situation. Context sources of this type include theuser’s social sphere (e.g., friends, relatives, or coworkers),people in the same event as the user (e.g., birthday, grad-uation, or holidays), or other PWT system users that aresimilar. A big challenge is that the availability of this con-text information is limited to certain public sources (suchas social networks), which are insufficient to optimize userexperiences in PWT systems. In order to exploit this typeof context effectively, we require software systems to dis-cover, monitor, manage, and process context sources differ-ent to the traditional ones. We suggest the implementationof SAS systems to cope with the challenges posed by the dy-namic nature of the user’s social persona (i.e., how, where,when, and with whom the user relates), and the hardwareand software technologies that support social interactions(e.g., social networks, collaborative applications, or commu-nication devices). Indeed, social context requires significantself-adaptive instrumentation.

5. CONCLUSIONSIn summary, we showed how to use self-adaptive systems

technology to solve challenges in the realization of PWTapplications Moreover, we demonstrated how PWT systemscan be designed and implemented on top of existing SEAMStechnologies. Indeed, PWT is an attractive application toleverage the advantages of self-adaptive systems. Finally,we identified two challenges that we are addressing in ourongoing research: the need to (1) develop web instrumen-tation to enable web interactions with dynamic capabilities,

4http://www.clicktale.com/5http://docs.seleniumhq.org/6http://solex.sourceforge.net/7http://mouseflow.com/

and (2) to exploit self-adaptation to gather relevant contextfrom non-traditional context sources, that not only can ap-pear at runtime but also cannot be fully specified at designtime.

6. REFERENCES[1] G. Blair, N. Bencomo, and R. France. Models@

run.time. Computer, 42(10):22–27, 2009.

[2] L. Castaneda, N. M. Villegas, and H. A. Muller.Towards personalized web-tasking: Task simplificationchallenges. In 2013 IEEE Ninth World Congress onServices (SERVICES), pages 147–153, 2013.

[3] M. R. Endsley. Toward a theory of situation awarenessin dynamic systems: Situation awareness. Humanfactors, 37(1):32–64, 1995.

[4] IEEE SERVICES 2013. 1st International Workshop onPersonalized Web Tasking (PWT 2013), 2013.

[5] J. Horkoff, E. Yu and G. Grau. iStart Guide. Online:http://istar.rwth-aachen.de/tiki-index.php?page=istarQuickGuide. Oct. 2013.

[6] J. O. Kephart and D. M. Chess. The vision ofautonomic computing. Computer, 36(1):41–50, 2003.

[7] R. Lemos, H. Giese, H. Muller, M. Shaw,J. Andersson, M. Litoiu, B. Schmerl, G. Tamura,N. Villegas, T. Vogel, D. Weyns, L. Baresi, B. Becker,N. Bencomo, Y. Brun, B. Cukic, R. Desmarais,S. Dustdar, G. Engels, K. Geihs, K. GAuschka,A. Gorla, V. Grassi, P. Inverardi, G. Karsai,J. Kramer, A. Lopes, J. Magee, S. Malek,S. Mankovskii, R. Mirandola, J. Mylopoulos,O. Nierstrasz, M. Pezze, C. Prehofer, W. Schafer,R. Schlichting, D. B. Smith, J. Sousa, L. Tahvildari,K. Wong, and J. Wuttke. Software engineering forself-adaptive systems: A second research roadmap. InSoftware Engineering for Self-Adaptive Systems II,volume 7475 of Lecture Notes in Computer Science,pages 1–32. Springer Berlin Heidelberg, 2013.

[8] H. Muller, M. Pezze, and M. Shaw. Visibility ofcontrol in adaptive systems. In Proceedings of the 2ndinternational workshop on Ultra-large-scalesoftware-intensive systems (ULSSIS 2008), pages23–26, 2008.

[9] V. E. Silva Souza, A. Lapouchnian, W. N. Robinson,and J. Mylopoulos. Awareness requirements. InSoftware Engineering for Self-Adaptive Systems II,volume 7475 of Lecture Notes in Computer Science,pages 133–161. Springer Berlin Heidelberg, 2013.

[10] N. Villegas, G. Tamura, H. Muller, L. Duchien, andR. Casallas. DYNAMICO: A Reference Model forGoverning Control Objectives and Context Relevancein Self-Adaptive Software Systems. In R. Lemos,H. Giese, H. A. Muller, and M. Shaw, editors,Software Engineering for Self-Adaptive Systems II,volume 7475 of Lecture Notes in Computer Science,pages 265–293, 2013.

[11] N. M. Villegas. Context Management andSelf-Adaptivity for Situation-Aware Smart SoftwareSystems. PhD thesis, University of Victoria, Canada,February 2013.