Lifecycle of Adaptive Agreements: A Pattern Language J. Santiago P´erez-Sotelo1, Carlos E. Cuesta1,2 , Holger Billhardt1 , and Sascha Ossowski1 1

2

CETINIA (Centre for Intelligent Information Technologies), University Rey Juan Carlos, Madrid, Spain VorTIC3 Research Group, School of Computer Science & Engineering, University Rey Juan Carlos, Madrid, Spain {josesantiago.perez,carlos.cuesta, holger.billhardt,sascha.ossowski}@urjc.es

Abstract. Adaptiveness can be considered as one of the most relevant features of complex distributed systems in general and Agreement Technologies (AT) in particular. In an agent-based, service-oriented and organisation-centric framework such as AT, a critical challenge is the definition of new organisations ”on the fly”, reacting to changes in the environment. This paper proposes a specific lifecycle for mutable agents in AT, which begins with a preliminary structure named initiative and ends up with a full-fledged organisation. This lifecycle is supported by elementary pieces (changents and shifter agents) and predefined templates, structured in the form of patterns. These adaptation patterns compose a pattern language, which defines the stages of the adaptive lifecycle. We present this pattern language and provide some specific examples. We also illustrate the usefulness of this approach by extending an existing AT-based application in the field of mHealth (mobile-Health) with additional adaptive capabilities.

1 Introduction As the complexity of the systems grows, not only in functionality, but also in heterogeneity, distribution, interactions, etc., adaptiveness becomes of foremost importance. This is particularly true for software systems based on Agreement Technologies (AT) [21,25]. Today’s difficulty goes beyond the administration of individual software. Routine tasks, previously managed by humans, are now being handled by the systems themselves; including many actions related to their own functions. It is already known that Multi-Agent Systems (MAS) have been developed in Artificial Intelligence (AI) field as a generic approach to solve complex problems [30]. They are decentralized systems that can afford interesting qualities, e.g. adaptability, scalability, among others. Even advanced approaches use the concept of organisations 

This work has been partially funded by the Spanish Ministry of Economy and Competitiveness through National Projects MULTIPLE (TIN2009-13838), OVAMAH (TIN2009-13839C03-02; co-funded by Plan E), CoMobility (TIN2012-31104) and iHAS (TIN2012-36586C03-02); and also by the Agreement Technologies initiative (CSD2007-0022, CONSOLIDERINGENIO 2012), in which all four authors participate.

C.I. Ches˜nevar et al. (Eds.): AT 2013, LNAI 8068, pp. 48–62, 2013. c Springer-Verlag Berlin Heidelberg 2013 

Lifecycle of Adaptive Agreements: A Pattern Language

49

to provide further structures. Moreover, the concept can be made even more flexible by adding actual self-adaptivity, i.e. having not only the capability to affect their settings, but also their own composition and types. AT have been introduced to simplify the development of this kind of systems. Within them, agreement architectures emphasize structural aspects, including in particular organisations of agents, service hierarchies and the capability to generate structures for emergent coordination. Instead of relying on a predefined coordination scheme, agreement architectures are able to grow and modify themselves. In an agent-based, service-oriented and organisation-centric framework such as AT, a critical challenge is the definition of new organisations ”on the fly”, reacting to changes in the environment and therefore dealing with the dynamism. The main goal is to provide adaptive organisations, where the emphasis is in the coordination mechanism, that is also adaptive, regardless of other structural concerns – such as the way in which their services are exported. The final objective is to provide a system with the capability of self-adaptation, i.e. the ability to adapt its behaviour to changes in the environment. Service-oriented agents gather together in the context of predefined controls and protocols, and the resulting aggregate can evolve applying the rules defined by what we call adaptation patterns. Eventually it would reach a “stable” agreement. This paper proposes a specific lifecycle for mutable agents in AT, which begins with a preliminary structure named initiative and ends up with a full-fledged organisation. This adaptive lifecycle is supported by elementary pieces, changents and shifter agents (their difference is explained in section 3), and predefined templates structured in the form of patterns. These adaptation patterns compose a pattern language, which defines the stages of the adaptive lifecycle. A pattern language, a concept imported from the fields of software engineering and architecture, is defined as a network of design patterns and their relationships. Thus its nature is related to design, rather than linguistics. The pattern language, conceived as a whole, describes a structured method: in this specific case, it superimposes the behavior which guarantees the underlying agent-based architecture to acquire self-adaptive features. The rest of this paper is structured as follows: section 2 gives a bird’s-eye-view on approaches related to self-adaptation; next section discusses the specific lifecycle. Section 4 describes the proposed pattern language originated by the aforementioned adaptations patterns, and provides some specific examples. Afterwards, the usefulness of this approach is illustrated by extending an existing AT-based application in the field of mHealth with additional adaptive capabilities. Finally, some conclusions are drawn and the lines of future work are outlined.

2 Related Work Many research lines have been presented to deal with adaptation and self-adaptation of software systems. In next paragraphs just a few of them are cited. Early approaches were tightly coupled with the source code and were specific for the application, so they were difficult to develop and also to maintain [9]; in [5] the focus is in the system architecture, e.g. when adaptation logic is separated from system functionality. Some research lines are centred on extending middleware approaches to provide

50

J. S. P´erez-Sotelo et al.

adaptation services to distributed systems, e.g. in [18] or the MADAM project [20]. Adaptation through the use of reflection has many approaches, at conceptual level and also technological level. A computational system can be considered reflective if it has an internal model of itself and if this model is causally connected to this system [10]. Every change in the model will be reflected in the system, and viceversa. This feature makes possible the adaptation of the system to changing conditions. On the other hand, aspect oriented programming can also be used to develop software systems with adaptation capabilities [6]. The main idea is to use the crosscutting-concerns to separate and encapsulate the aspects scattered in the code. These characteristics allow the reuse of the aspect in different software units, and obtain systems with structures that can be developed, extended, adapted, etc. easily. Autonomic Computing is another approach to obtain adaptable software system [16]. The challenge is to control self-managing components distributed system to produce emergent autonomic behavior. Autonomic computing applies the concept of a control loop to monitor, evaluate, and adapt a system component. In [7] a mixed-mode adaptation is proposed. The interactions between the old system and the new system are allowed during the adaptation process. Zhang et al. [31] propose a development process for dynamic and adaptive systems driven by models, and they focus their work in behavioural models. In the SELFMAN project [27] two important areas are used to develop automanaged systems, the autonomic computing and structured overlay networks. In [17] the authors propose a method to plan dynamic adaptations based in reinforcement learning of auto-managed systems. Ramirez and Cheng [24] propose the use of adaptationoriented design patterns that can be leveraged from one adaptive system to another. This pattern-based design separates the functional logic from the adaptive logic, resulting in a system that supports dynamic adaptation and is easier to maintain and analyze. In contrast, our approach proposes not only the use of adaptation patterns, but an architecture defined as service-oriented, organisation-centric, and agent-based. The main idea is to deal with the dynamism of the environment, and the system itself, from the very beginning, when the objective and the composition of the system are being defined.

3 The Adaptive Lifecycle We have developed this adaptive approach as part of the AT sandbox to provide a system with the capability of self-adaptation. We set out from a distributed software systems whose elements have sophisticated reasoning and coordination capabilities (henceforth called agents). Agents provide services to other agents, and may choose to be part of an organisation. In this service-oriented, organisation-centric and agent-based framework, elements interact with each other based on the notion of agreement and negotiate to reach both their individual and system-wide goals. In large-scale open distributed systems of this type, adaptations cannot be based on a predefined strategy, but must emerge dynamically from system dynamics. So we can conclude that it defines a self-organising system. The lifecycle of our self-organising structures is presented in Figure 1 [11]. The cycle begins with a single agent, (i) in the figure, capable of performing certain interactions and with the potential of exporting some services. When such an agent initially

Lifecycle of Adaptive Agreements: A Pattern Language

51

Fig. 1. Lifecycle of a self-organising structure. From a single agent to a full organization [11].

52

J. S. P´erez-Sotelo et al.

enters the system, it does not belong to any organisation. However, it finds a number of predefined controls and protocols (ii). The former can be seen as mechanisms that either enforce or forbid specific interactions (or achitectural connections). Self-adaptive structures, being typically centralized [3], show many classic examples of this kind: most of them manifest explicit control loops, inspired in regulators of classic control theory. The protocols, which enable or channel interactions, are based on consensus and agreements. They can be described generically as the way to control decentralized (even distributed) structures [13]. Basically, when protocols are present, every agent knows the way to interact with the rest; it is necessary to comply with them to be able to communicate, but at the same time they are also regulating the development of the interacting structure itself. Both mechanisms define a wide spectrum of regulation, in which agent organisations and their architectures are simultaneously harnessed by atomic, unary controls (such as norms, limits, locks, control loops or constraints) and multiple, connective protocols (such as hubs, bridges, channels, or spaces). Therefore agent’s interaction is guided and it can maintain structured conversations with other agents, composing informal groups of agents (iii). It is interesting to clarify the differences between our kinds of mutable agents. A shifter agent is an agent that changes when it is inducted to do it. For example it can use specials functions belonging to the middleware that are not allowed to normal agents; or can work together with another agent with different functions and in parallel, and both of them can be taken as only one agent that has changed. On the other hand, a changent is an agent of change. It is the one that inducts the change on the rest of the elements in the pattern. For example enabling shifters to use the specials functions of the middleware, or allowing an agent to work in parallel with another in order to form a shifter [11]. At some point, an external change occurs, and the system must react with an adaptive behaviour. Of course, this is the functionality that must trigger the formation of our self-organising structures. To be able to achieve the desired reaction, the system is provided with a number of adaptation patterns (iv). These are neither closed strategies nor full descriptions of a reactive behaviour, but partial definitions of elements and relationships, which include enough information for an agent to learn how to perform a certain fine-grained, but relevant, behaviour. This behaviour includes the definition of some protocols, as mentioned above. Therefore, under the influence of an adaptation pattern, certain agents within the group acquire specific functions, and begin to form an actual structure: this is what we call an initiative (v), which is the key of our adaptive approach. This process continues and the initiative grows and evolves. Seeing as a biological metaphor, i.e. a stem cell [15], it evolves acquiring concrete functionalities until existing inhibitors stop this process to prevent the evolution into cancer [11]. Similarly, when the initiative is already fulfilling all the required functions - every service is being served by some agent - our inhibitors (vi) transform the initiative into a full organisation (vii). These organisations are adaptive by formation, and are themselves able to evolve and participate in larger agreements - which could trigger the formation of yet another composite organisation. In summary, the process guarantees that the result is indeed an adaptive agreement architecture.

Lifecycle of Adaptive Agreements: A Pattern Language

53

4 The Pattern Language The concept of pattern language, just like the notion of pattern itself, was originally defined by Christopher Alexander in his seminal work [1,2] within the field of (building) architecture. The well-known concept of design pattern [14,8] can be summarized as a template description of a solution to a problem in a specific context; similarly, the notion of pattern language is roughly defined as a network of patterns, i.e. a set of patterns which work together to define some complex activity or design strategy. Alexander’s definition conceives the pattern language (“of design”) as a structured method to described a good design practice to a complex problem. “Each pattern [is] connected to other patterns, so that you grasp the collection (...) as a whole, as a language, within which you can create an infinity variety of combinations” [1]. And also “No pattern is an isolated entity. Each pattern can exist in the world, only to the extent that it is supported by other patterns” [1]. Pattern languages are not conceived as closed definitions – just like individual patterns must be adapted to specific scenarios, pattern languages can be easily extended with the addition of new patterns and relationships. Therefore, despite the intuition behind the name, the pattern language is not a classic language, such as a programming language, but rather a network of design knowledge constructs. It can be conceived as a language, as it has a vocabulary (the set of patterns), a syntax (their relationships) and a grammar (how they operate to solve the problem, both individually and as a whole). But it is not a language for communication; it is conceived for a different complex activity, i.e. design. Since its original inception, the concept of pattern language has been applied to many complex solutions, particularly at the architectural level [8]. It has even been applied within the specific context of agent-oriented architectures, specifically to provide adaptive capabilities [28] – in this particular case, to implement the equivalent of a MonitorAnalyse-Plan-Execute (MAPE) [16] loop inside this kind of system. The purpose of our pattern language is to introduce the steps defining a lifecycle able to guarantee some adaptive properties. As we can see in Figure 2 our pattern language consists in sixteen adaptation patterns. According to changes in the enviroment, some of them may be used in parallel and some in a sequential manner. The pattern language can show the relationship between the patterns as well as the events that trigger their use. Their interactions contribute to tackle the whole dynamic of the environment. In this paper we focus in the description of the pattern language as a whole; therefore, the structure of individual patterns is not described in detail. The interested reader can refer to [22], where the Gathering pattern – and hence the pattern structure itself is described in detail. Our adaptation patterns are: 1. Gathering – this pattern describes the creation of an initial proto-organisation, by joining a set of previously unrelated agents in the same place. 2. Surveyor Election – describes the way in which an organisational leader is chosen among the agents in the gathering. Different election algorithms can be applied,

54

J. S. P´erez-Sotelo et al.

Fig. 2. The Initiative Pattern Language

Lifecycle of Adaptive Agreements: A Pattern Language

3.

4.

5.

6. 7.

8. 9.

10.

11. 12. 13.

14.

55

depending on the circumstances. The pattern must be adapted to use the most adequate algorithm in each case. There is an extensive literature on election algorithms in distributed systems [19], so this needs not to be discussed in detail here. Many choices (e.g. ring algorithms) should be fit, having into account the results in [12] to ensure reliability. Surveyor – describes the basic behavior of the leading agent, that is, mostly routing messages towards the correct agent, to the best of his knowledge. It functions as a coordinator because the organisation does not exist yet. Once a surveyor has been defined, we can consider that a simple gathering of agents actually becomes an initiative. Surveyor Change – triggers the protocol to (potentially) substitute the current surveyor. Reasons to trigger this change range from the addition of another candidate, to the surveyor’s own desire to resign. If successful, it must trigger an election process; it can also decide to maintain the current situation. Fac¸ade – defines a fac¸ade (i.e. a committed agent) to perform any interaction to the outside world, i.e. everybody not belonging to the initiative. This makes possible to externally conceive the initiative as a single entity. It is completely analogous to the classic Fac¸ade pattern [14]. Update Fac¸ade – relieves the current fac¸ade from its responsibilities, and assigns them to a new agent. Mediator – provides an agent with the capability to act as an intermediating intelligent entity between other agents which would be otherwise unable to communicate. In addition, it has the possibility to access their information, although indirectly. This definition is “internal”: mediators act within the limits of the initiative. The concept of mediator is well-known in computer science and database research [29]. It is partially analogous to the Mediator pattern defined in [14]. New Mediator – triggers the assignment of a new mediator, by reacting or foreseen the need of such an element. Thru Mediator – establishes the connection between a new (potentially unconnected) agent and an already defined mediator, therefore providing it with the potential to interact to the rest of the initiative. Full Mesh – provides a full-mesh connection between an incoming agent and the rest of the elements in the initiative. It is the semantic opposite of the previous one: the new agent is able to directly connect to everybody, without requiring any mediators. Retirement – describes the process that an agent must follow to abandon the intiative, becoming a “free agent” again. Consolider – describes the process which consolidates and registers an initiative, transforming it into a full-fledged organisation. Planner – an agent acquires the capabilities to plan an intelligent answer to some situation. A standard planner, but one which must take into account the resources currently present in the initiative. Transformer – describes the process to transform some agent from a defined role into another. This can be specific to a certain pattern language or semantic context.

56

J. S. P´erez-Sotelo et al.

15. Monitor – every interaction within the initiative is captured and filtered according to the susbcriptions in this monitor. It makes possible for the surveyor to discover the current capabilities in the changing organisation. There might be several monitors, with different filtering instructions. 16. Terminator – triggers the ending of the current initiative, without becoming an organisation; it is the opposite of Consolider. It is automatically triggered once the number of members falls below two. It is import to note that our pattern language turns around the basic structure we called initiative. As it was already explained, an initiative is an emergent structure that evolves with the dynamic of the environment. It is a preliminary group of individuals (agents) which assemble in a certain structure, generated by a set of controls and protocols [23]. Next paragraphs explain the relation between the patterns previously described and their use in the lifecycle of our self-organising structures. According to section 3, the cycle begins with a single agent, but for some reason, e.g. a crisis situation, many agents are called to deal with this situation, which successful resolution will be the main objective of the future organisation. To achieve this the Gathering pattern must be used. This pattern includes changents or “agents of change” [22], which induct the change on the rest of elements in the pattern. Once all the agents know each other the Surveyor Election pattern can be triggered in order to chose an organisational leader. It includes one among many election protocols. Right after that, the Surveyor pattern can be used. It includes a shifter agent or “agent that changes”, e.g. an agent has changed when it became into a leader. During the emergence process this pattern must control the growing of the initiative itself, both to decide when to insert new elements, and when the preliminary group reaches a “stable” state. The growing of the emergent organisation can be detained using the pattern post conditions, which act as inhibitors. The latter allow the initiative to achieve a steady state or not. As it also has access to the pattern library, it can trigger the Consolider pattern at that moment. The latest allows the preliminary structure to end up as a full-fledged organisation. This “stable” structure is achieved when all the participants can afford the necessary agreement in order to solve the problem or gain the main objective that caused their union. The resulting full-fledged organisation is then registered as an unit and is conceptually similar to other organisations in several MAS approaches. As the leader is working inside the initiative, Surveyor may also decide that the emergent entity needs a representative, so the group can be seen as an unity from the outside. Therefore it may trigger the Fac¸ade pattern. It not only represents the group in terms of interactions whit the outside world, it can also redirect any incoming communication. If actual Fac¸ade for any reason has to be changed, e.g. the representative has to leave the emergent group because it is needed in another location, the Update Fac¸ade pattern can be used. As a next step in this path of the pattern language the initiative could be considered “stable” and ready to become an organisation. The Consolider pattern is triggered and, according to initials requeriments and pattern post conditions, can assume the arrangement of the full organisation and extinguish the initiative.

Lifecycle of Adaptive Agreements: A Pattern Language

57

During the preliminary structure’s emergence process, the group is not yet stablished and data services are probably not working. In this case the Mediator pattern can be used and at least one agent must act as a mediator. Besides the functions described in the beginning of the section, this agent is able to perform some translations if necessary, e.g. from the initiative’s communications format into the new agent’s communication format. Again, if actual Mediator has to be changed, the New Mediator pattern can be used to make the change. The Thru Mediator pattern also allows the entering of new individuals into the emergent group. The pattern called Full Mesh can be used when all the components of the initiative know each other and can maintain conversations. It is also used as a default strategy when a new member has to enter to the group. In the event one or more agents have to leave the initiative, either by choice or another reason, the Retirement pattern is triggered and the agents can now abandon the group. The Monitor pattern can be used sequentialy with the patterns which are generating the initiative and its function is to control this emergence process. It captures and filters every interaction within the initiative. It observes the conditions of the changing group and allows corresponding reactions. This can also be taken as the first step for a MAPE loop [16]. According to this, it could induct the trigger of either patterns Surveyor Change or New Mediator, with corresponding changes. At certain point of the path, it can be necessary a planification of actions and/or changes. In this case the classic MAPE loop is very useful. It can be realised by the Planner pattern, which can induct transformations inside the initiative and trigger the Transformer pattern. The latest includes changents and shifters to achieve necessary changes on individuals inside the pattern. These changes may also suggest a change of pattern. In the event of no agreement can be achieved, and therefore the initiative cannot end up in an organisation to solve the main objective, the Terminator pattern must be used to extinguish the preliminary group. This pattern frees the agents and removes the communication channels created. This pattern is also used when only one entity remains in the location, and therefore there is no more an initiative.

5 Proof-of-Concept: Adaptive mHealth In order to illustrate the situation in which an adaptive architecture would be a better solution, this section presents a proof-of-concept describing the use of some adaptive patterns in a scenario from the medical emergencies domain. This example is hypothetical but based in real situations, which are related to the mHealth demonstrator. This demonstrator is an evolutionary prototype currently under development in the Agreement Technologies Project [4] and with the cooperation of SUMMA112 [26]. This entity manages the medical emergencies in the Autonomous Region of Madrid, Spain. Therefore, the main application scenario for the demonstrator is the management of medical emergency service. A medical emergency service deals with the task of providing out-of-hospital assistance to people in case of sudden health problems. The prototype is based on a distributed application that provides support in the operation of

58

J. S. P´erez-Sotelo et al.

medical emergency services, together with mechanisms for coordinating ambulances, reallocation of idle ones, and patient assignment within a region of interest. In particular, the application automates the communication between the entities, the basic decision making procedures as well as the exchange of medical information which may be obtained from remote sources. Regarding the overall quality of the application there is an interest in analysing, testing and evaluating different coordination or organization mechanisms that may help to increase the mentioned quality. In order to do that, a simulation tool has been implemented for running experiments with the medical emergency transportation application in (simulated) semi-realistic setting over periods of time. The next step in the demonstrator’s development is to achieve real adaptiveness to changing environment during the emergency services. In order to illustrate our proposed Adaptive mHealth we will use the simulation tool, which allows interactions with the user. The proposed scenario is as follows:

Fig. 3. Gathering pattern activated

There is a crisis in an urban park situated west of central Madrid and there are about 20 injured people. The management of the emergency is already under supervision of SUMMA112, which has sent several ambulances to the location. Every ambulance is represented by an agent. As a result of at least three ambulances have reached the park, (Figure 3), the Gathering pattern is activated by the tool. The agents can maintain structured conversations, composing an informal group. They could need a leader to structure the working group, therefore the Surveyor Election pattern can be triggered

Lifecycle of Adaptive Agreements: A Pattern Language

59

and after that the leader activates the Surveyor pattern. To interact with the mHealth system an ambulance is chosen as a representative using the Fac¸ade pattern. Every time an ambulance reaches the location, the system triggers the Full Mesh pattern in order to incorporate it into the group. The initiative is already formed but there is no need to consolidate because the organisation is not going to last long after the crisis situation. At some point, an external change occurs, e.g. SUMMA112 requests one or more idle ambulances for another situation, and the system must react with an adaptive behaviour. In this case the new situation is a car crash in a road tunnel near the first crisis and there are about seven cars affected. Unfortunately there is no ambulance idle in the system to deal with the accident. Therefore, SUMMA112 requests through the Fac¸ade some ambulances to send to the car crash location. The Surveyor accepts the request and decides how many ambulances can be sent, e.g. taking into account if the ambulances have already finished their job. To release some of them the Retirement pattern is activated, so they leave the park and move to the tunnel. When they reach the location the Gathering pattern is activated again and the cycle begins one more time in order to form the initiative. In case that the initiative is already conformed and an ambulance must transfer a patient to a hospital (see Figure 4), the Retirement pattern is activated as part of the initiative functionality and not only when the latest is falling apart. As the proposed scenario is an emergency example there is no need to consolidate the initiative because the crisis has to be solved as soon as posible and the organisation is not going to last long after this situation. Therefore, none of the Initiatives have ended up in an “stable” organisation, so the Consolider pattern was not used.

Fig. 4. Retirement pattern activated

60

J. S. P´erez-Sotelo et al.

Eventually, as explained before, an Initiative can be extinguished with the use of the Terminator pattern when only one ambulance remains in the location. When the group looses its ambulances theTerminator pattern is triggered and the Initiative finishes. As final comment, it is important to note that the simulation tool is not fully adaptive because all the patterns are not triggered automatically. Part of the behaviour is hardcoded in the tool because the domain is not totally unknown and we have the knowledge about conditions to trigger certain patterns. The development are still evolving, but even at this stage, the existing fragments of the approach have already proven its utility. Current results suggest that the adaptive architecture is indeed feasible and the final objective is to achieve automatically activation and deactivation of the patterns.

6 Conclusions Agreement technologies provide a higher degree of flexibility and adaptivity than most previous agent-based (even organisation-centric) technologies. This flexibility is mostly due to their layered conception and their organisational structure. In particular, the negotiation layer makes possible to reconsider the definition of the relationship between organisations (and hence their interaction protocols), providing a significant degree of high-level adaptiveness. However, these technologies can also benefit of many of the recent advances in selfadaptive systems; most of them refer to low-level adaptivity, and hence they must be considered below the organisational layer. This influence is better captured at the architectural level, as it refers to interactions between the system’s basic building blocks, i.e. the changing relationship between components – the way in which agents enter and define organizations. Under this influence, agreements mutate into adaptive agreements, as described in previous sections. Architectural solutions to achieve a greater adaptiveness are described by means of patterns, which are also used to superimpose this adaptive behavior on top of the basic technology. In this paper we have described a set of related patterns –a pattern language– which define a many-branched behavioral path, outlining the core of an adaptive protoorganisation, the initiative. As described in section 3, the elements of this initiative acquire different capabilities and behaviors as they reach different stages in this path, defining an “adaptive lifecycle” in which low-level adaptive capabilities are effectively provided by architectural means. The solution presented here is not yet complete: the adaptation process is not yet fully automated, and hence we are not able to claim that this approach provides selfadaptation. But this mechanism does provide a great degree of flexibility –new patterns can be added at any moment, and therefore the platform can be easily extended–, and our experiments with the proof-of-concept system (the Adaptive mHealth simulator) supports our original intuition – i.e. that this approach is indeed feasible and can be used to provide extended adaptive capabilities into agreement technologies. Though our experiments here concentrate on the initiative-based strategy, we should also note that this approach is not limited by it. Adaptation patterns can be used to define

Lifecycle of Adaptive Agreements: A Pattern Language

61

a completely different adaptive approach - you just need to provide an adequate pattern language. The basic mechanism will still trigger the corresponding patterns once the preconditions are met, until an inhibitor decides that it must be supressed. We have not fully explored the potential of such new strategies –or their combination with existing ones–, and this will be the subject of most of our future work.

References 1. Alexander, C.: A Pattern Language: Towns, Buildings, Construction. Oxford University Press (1977) 2. Alexander, C.: The Timeless Way of Building. Oxford University Press (1979) 3. Andersson, J., de Lemos, R., Malek, S., Weyns, D.: Modeling dimensions of self-adaptive software systems. In: Cheng, B.H.C., de Lemos, R., Giese, H., Inverardi, P., Magee, J. (eds.) Software Engineering for Self-Adaptive Systems. LNCS, vol. 5525, pp. 27–47. Springer, Heidelberg (2009) 4. AT. Agreement Technologies Project (April 2013), http://www.agreement-technologies.org 5. Baresi, L., Guinea, S., Tamburelli, G.: Towards decentralized self-adaptive component-based systems. In: Proceedings of the 2008 International Workshop on Software Engineering for Adaptive and Self-managing Systems (SEAMS 2008), pp. 57–64. ACM, New York (2008) 6. Bened´ı, J.P.: PRISMA: Aspect-Oriented Software Architectures. PhD thesis, Universidad Polit´ecnica de Valencia, Valencia, Espa˜na (2006) 7. Biyani, K.N., Kulkarni, S.S.: Mixed-mode adaptation in distributed systems: A case study. In: Proceedings of the 2007 International Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2007), p. 14. IEEE Computer Society, Washington, DC (2007) 8. Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P., Stal, M.: Pattern-Oriented Software Architecture, Volume 1: A System of Patterns. John Wiley & Sons (1996) 9. Cazzola, W., Savigni, A., Sosio, A., Tisato, F.: A fresh look at programming-in-the-large. In: The Twenty-Second Annual International Computer Software and Application Conference (COMPSAC 1998), Viena, Austria (1998) 10. Cuesta, C.: Arquitectura de software din´amica basada en reflexi´on. PhD thesis, Departamento de Inform´atica - Universidad de Valladolid, Valladolid, Espa˜na (2002) 11. Cuesta, C., Perez-Sotelo, J.S., Ossowski, S.: Self-organising adaptive structures: The shifter experience. European Research Consortium for Informatics and Mathematics - ERCIM News 2011(85), 35–36 (2011) 12. Fischer, M.J., Lynch, N., Paterson, M.S.: Impossibility of distributed consensus with one faulty process. Journal of the ACM 32(2), 374–382 (1985) 13. Galloway, A.R.: Protocol: How Control Exists after Decentralization, 1st edn. The MIT Press (2004) 14. Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley (1995) 15. Ia˜nez Pareja, E.: Celulas Madre y Clonacion Terapeutica (April 2013), http://www.ugr.es/˜eianez/Biotecnologia/clonembrion.htm 16. Kephart, J.O., Chess, D.M.: The vision of autonomic computing. Computer 36(1), 41–50 (2003) 17. Kim, D., Park, S.: Reinforcement learning-based dynamic adaptation planning method for architecture-based self-managed software. In: Proceedings of the 2009 International Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2009), Vancouver, Canada (May 2009)

62

J. S. P´erez-Sotelo et al.

18. Kon, F., Costa, F., Blair, G., Campbell, R.H.: The case for reflective middleware. Communications of the ACM 45(6), 33–38 (2002) 19. Lynch, N.: Distributed Algorithms. Morgan Kaufmann (1996) 20. Mikalsen, M., Paspallis, N., Floch, J., Stav, E., Papadopoulos, G.A., Chimaris, A.: Distributed context management in a mobility and adaptation enabling middleware (madam). In: Proceedings of the 2006 ACM Symposium on Applied Computin, pp. 733–734. ACM (2006) 21. Ossowski, S. (ed.): Agreement Technologies. Law, Governance ant Technology Series, vol. 8. Springer (2013) 22. P´erez-Sotelo, J.S., Cuesta, C.E., Ossowski, S.: Adaptation patterns in multi-agent architectures: The gathering pattern. In: Meersman, R., Dillon, T., Herrero, P. (eds.) OTM-WS 2011. LNCS, vol. 7046, pp. 657–661. Springer, Heidelberg (2011) 23. Perez-Sotelo, J.S., Cuesta, C.E., Ossowski, S.: The role of agreement technologies in the definition of adaptive software architectures. SADIO Electronic Journal of Informatics and Operations Research 10(1), 53–67 (2011) 24. Ramirez, A.J., Cheng, B.H.C.: Design patterns for developing dynamically adaptive systems. In: Proceedings of the 2010 ICSE Workshop on Software Engineering for Adaptive and SelfManaging Systems (SEAMS 2010), pp. 49–58. ACM, New York (2010) 25. Sierra, C., Botti, V., Ossowski, S.: Agreement computing. KI - K¨unstliche Intelligenz 25, 57–61 (2011), doi:10.1007/s13218-010-0070-y 26. SUMMA112. Servicio de Urgencias Medicas de la Comunidad de Madrid (April 2013), http://bit.ly/158tuB6 27. Van Roy, P., Haridi, S., Reinefeld, A., Stefani, J.-B., Yap, R., Coupaye, T.: Self management for large-scale distributed systems: An overview of the SELFMAN project. In: de Boer, F.S., Bonsangue, M.M., Graf, S., de Roever, W.-P. (eds.) FMCO 2007. LNCS, vol. 5382, pp. 153–178. Springer, Heidelberg (2008) 28. Weyns, D.: A Pattern Language for Multi-Agent Systems. In: Proc. WICSA/ECSA 2009, pp. 191–200. IEEE Computer Society (2009) 29. Wiederhold, G.: Mediators in the Architecture of Future Information Systems. IEEE Computer 25(3), 38–49 (1992) 30. Wooldridge, M.: An Introduction to MultiAgent Systems, 2nd edn. Wiley Publishing (2009) 31. Zhang, J., Cheng, B.H.C.: Model-based development of dynamically adaptive software. In: Proceedings of International Conference of Software Engineering (ICSE 2006), Shangai, China, pp. 371–380. ACM (May 2006)