Papers by Michael Winikoff
Wiley Series in Agent Technology Series Editor: Michael Wooldridge, Liverpool University, UK The ... more Wiley Series in Agent Technology Series Editor: Michael Wooldridge, Liverpool University, UK The 'Wiley Series in Agent Technology' is a series of comprehensive practical guides and cutting-edge research titles on new ...
Bookmarks Related papers MentionsView impact
Agent interaction descriptions (or protocols) are a key aspect of the design of multi-agent syste... more Agent interaction descriptions (or protocols) are a key aspect of the design of multi-agent systems. However, in the authors’ extensive experience, the notations commonly used for specification are both difficult to use, and lack expressiveness in certain areas. Some desired modular representations are im- possible to express, while others result in specifications that are unwieldy and difficult to follow. In this paper we present a new notation for expressing interac- tion protocols, focussing on key issues that we have found to be problematic: the ability to define flexible data-driven protocols; representation of roles including their mapping to agents; and hierarchical modularity. We provide the semantics for our notation and illustrate its use with three diverse examples. Finally we eval- uate this notation based on objectively assessable criteria that we argue contribute substantially to pragmatic usability.
Bookmarks Related papers MentionsView impact
Agent systems are used for a wide range of applications, and tech- niques to detect and avoid def... more Agent systems are used for a wide range of applications, and tech- niques to detect and avoid defects in such systems are valuable. In particular, it is desirable to detect issues as early as possible in the software development lifecycle. We describe a technique for checking the plan structures of a BDI agent design against the re- quirements models, specified in terms of scenarios and goals. This approach is applicable at design time, not requiring source code. A lightweight evaluation demonstrates that a range of defects can be found using this technique.
Bookmarks Related papers MentionsView impact
Before deploying a software system we need to assure ourselves (and stakeholders) that the system... more Before deploying a software system we need to assure ourselves (and stakeholders) that the system will behave correctly. This assurance is usually done by testing the system. However, it is intuitively obvious that adaptive systems, including agent-based systems, can exhibit complex behaviour, and are thus harder to test. In this paper we examine this “obvious intuition” in the case of Belief-Desire-Intention (BDI) agents. We analyse the size of the behaviour space of BDI agents and show that although the intuition is correct, the factors that influence the size are not what we expected them to be. Specifically, we found that the introduction of failure handling had a much larger effect on the size of the behaviour space than we expected. We also discuss the implications of these findings on the testability of BDI agents.
Bookmarks Related papers MentionsView impact
What are the types of mistakes (“faults”) that novice GOAL pro- grammers make, and how do they ma... more What are the types of mistakes (“faults”) that novice GOAL pro- grammers make, and how do they manifest as failures? This ques- tion is important since it has significant implications to the ongoing design of GOAL, and other agent-oriented programming languages; to the ongoing development of tools that support GOAL program- mers; and to how we teach agent-oriented programming. In this paper we develop taxonomies for faults and for failures. We then classify the faults and failures that occur in a collection of programs by novice GOAL programmers. This provides empirical data which we use to make recommendations regarding the GOAL language, its support tools, and how it is taught.
Bookmarks Related papers MentionsView impact
Testing multi-agent systems is a challenge, since by definition such systems are distributed, and... more Testing multi-agent systems is a challenge, since by definition such systems are distributed, and are able to exhibit autonomous and flexible behaviour. One specific challenge in testing agent programs is developing a collection of tests (a “test suite”) that is adequate for testing a given agent program. In order to develop an adequate test suite, it is clearly important to be able to assess the adequacy of a given test suite. A well-established technique for assessing this is the use of mutation testing, where mutation operators are used to generate vari- ants (“mutants”) of a given program, and a test suite is then assessed in terms of its ability to detect (“kill”) the mutants. However, work on mutation testing has focussed largely on the mutation of procedural and object-oriented languages. This paper is the first to propose a set of mutation operators for a cognitive agent- oriented programming language, specifically GOAL. Our mutation operators are systematically derived, and are also guided by an exploration of the bugs found in a collection of undergraduate programming assignments written in GOAL. In fact, in exploring these programs we also provide an additional contribution: evi- dence of the extent to which the two foundational hypotheses of mutation testing hold for GOAL programs.
Bookmarks Related papers MentionsView impact
An expanded version of this paper has subsequently been published in JAAMAS:
Akin Günay, Michae... more An expanded version of this paper has subsequently been published in JAAMAS:
Akin Günay, Michael Winikoff, and Pinar Yolum. Dynamically Generated Commitment Protocols in Open Systems. Journal of Autonomous Agents and Multi-Agent Systems (JAAMAS). Volume 29, Number 2, pages 192-229. March 2015. doi:10.1007/s10458-014-9251-7
Bookmarks Related papers MentionsView impact
Bookmarks Related papers MentionsView impact
Introductory programming courses have been continuously reported as having a high rate of failure... more Introductory programming courses have been continuously reported as having a high rate of failure or withdrawal. This research aims to develop a new approach for teaching novice programming, which is both easy to introduce and effective in improving novice learning. Our approach combines three key ideas: using a visual programming language; using strategies, specifically using the concepts of ―goal‖ and ―plan‖; and having a well-defined process. We present a way of representing goals and plans in a visual notation together with a plan library that we developed in a visual programming environment (VPE). A key feature of the approach is that a design, i.e. an unmerged ―plan network‖, is executable and can be tested, giving feedback in the VPE. Furthermore, we describe a detailed process for using existing plans and building new plans in the VPE. This approach had been evaluated experimentally and the results indicated its potential to
significantly improve teaching programming to novices.
Bookmarks Related papers MentionsView impact
creasingly other goal types are being studied such as maintenance goals, which represent a state ... more creasingly other goal types are being studied such as maintenance goals, which represent a state the agent wants to maintain, and perform goals, which represent the goal to execute certain actions (e.g., [4, 7, 8, 11]). However, only considering a small number of goal types can be limiting, since in practical applications there may be goals that cannot be captured well by achievement or mainte- nance or perform goals.
To make this discussion more concrete, consider a personal as- sistant agent that manages a user’s calendar and tasks. One goal the agent may have is booking a meeting. This would typically be modelled as an achievement goal that aims to bring about a state where all required participants have the meeting in their calendar. However, in practice, diaries change, and we want to ensure that the meeting remains in participants’ diaries, and that should a key participant become unable to attend, a new time will be negoti- ated. This is not captured by an achievement goal. Rather, it is better modelled by a combined “achieve then maintain” goal which achieves a certain condition, and then maintains it over a certain time period. Another task that we might want the agent to under- take is to ensure that booking travel is not done until the budget is approved. Note that budget approval may be under the control (or perhaps just influence) of the agent, i.e. the agent may have plans for attempting to have the budget approved. Alternatively, it may be completely outside the agent’s control, in which case the agent can just wait for it to happen and then enable the travel booking process.
A number of papers have taken this line of research a step fur- ther by taking arbitrary Linear Temporal Logic (LTL) formulae as goals [1, 2, 12, 13, 16], rather than considering specific goal types. The advantage of this approach is that it does not restrict the goal types that can be used. However, a possible disadvantage is that it requires extensive alterations of a more basic agent programming framework, the practical implications of which are not yet clear.
Temporal logic is also used by MetateM [10], but it is used directly for agent execution, whereas we use temporal logic as a design framework for specifying goal types which are mapped to existing implementations of achieve and maintenance goals. Addi- tionally, MetateM requires a particular format for its rules: all rules are in one of the three forms: start → φ, or ψ → φ or ψ → φ where φ is a disjunction of literals, ψ is a conjunction of literals, and φ is a positive literal.
In this paper, we propose an approach that is somewhere in be- tween those focusing on a limited set of goal types and those in which arbitrary LTL formulae can be taken as goals. We propose an approach in which goals that are represented by relatively com- plex LTL formulae are operationalized by translating these LTL formulae to more basic achieve and maintain goals. The advantage of this approach is that the goal types can be integrated in existing
Rich Goal Types in Agent Programming
Mehdi Dastani Utrecht University The Netherlands [email protected]
M. Birna van Riemsdijk Delft University of Technology The Netherlands [email protected]
Michael Winikoff University of Otago
New Zealand [email protected]
Goals are central to the design and implementation of intelligent software agents. Much of the literature on goals and reasoning about goals in agent programming frameworks only deals with a limited set of goal types, typically achievement goals, and some- times maintenance goals. In this paper we extend a previously proposed unifying framework for goals with additional richer goal types that are explicitly represented as Linear Temporal Logic (LTL) formulae. We show that these goal types can be modelled as a com- bination of achieve and maintain goals. This is done by providing an operationalization of these new goal types, and showing that the operationalization generates computation traces that satisfy the temporal formula.
Bookmarks Related papers MentionsView impact
Previous research on modelling and monitoring norms, contracts and commitments has studied the se... more Previous research on modelling and monitoring norms, contracts and commitments has studied the semantics of concepts such as obligation, permis- sion, prohibition and commitment; languages for expressing behavioural con- straints (such as norms or contracts) to be followed by agents in specific con- texts; and mechanisms for run-time monitoring of fulfilment and violation of these constraints. However, there has been little work that provided all of these features while also allowing the current expectations of agents, and the fulfilment and violation of these expectations to be expressed as first-class constructs in the language. This paper demonstrates the benefits of providing this capability by considering a variety of use cases and demonstrating how these can be addressed as applications of a previously defined temporal logic of expectations and an as- sociated monitoring technique.
Bookmarks Related papers MentionsView impact
One of the defining characteristics of intelligent software agents is their ability to pursue goa... more One of the defining characteristics of intelligent software agents is their ability to pursue goals in a flexible and reliable manner, and many modern agent platforms provide some form of goal construct. However, these platforms are surprisingly naive in their handling of interactions between goals. Most pro- vide no support for detecting that two goals interact, which allows an agent to interfere with itself, for example by simultaneously pursuing conflicting goals. Previous work has provided representations and reasoning mechanisms to iden- tify and react appropriately to various sorts of interactions. However, previous work has not provided a framework for reasoning about goal interactions that is generic, extensible, formally described, and that covers a range of interaction types. This paper provides such a framework.
Bookmarks Related papers MentionsView impact
A critical issue in software maintenance and evolu- tion is change propagation: given a primary c... more A critical issue in software maintenance and evolu- tion is change propagation: given a primary change that is made in order to meet a new or changed requirement, what additional, secondary, changes are needed? We have previously developed techniques for effectively supporting change propagation within design models of intelligent agent systems. In this paper, we pro- pose how this approach is applied to support change propagation within UML design models. Our approach offers a number of advantages in terms of saving substantial time writing hard-coded rules, ensuring soundness and completeness, and at the same time capturing the cascading nature of change propagation. We will also present and discuss the results of an evaluation performed to assess the scalability of our approach.
Bookmarks Related papers MentionsView impact
We briefly review the current state of play in the area of agent-based software engineering, and ... more We briefly review the current state of play in the area of agent-based software engineering, and then consider “what next?”. We discuss a range of market- ing activities that will together help in making people from other communities aware of work in this area. We then outline a number of research topics that are seen as vital to the future of the field. Although (as always) more research is needed, recent progress in both research and industrial adoption has been most encouraging, and the future of agent-based software engineering looks bright.
Bookmarks Related papers MentionsView impact
Abstract. The use of computers to mediate social interactions (e.g. blogs, chat- ting, facebook, ... more Abstract. The use of computers to mediate social interactions (e.g. blogs, chat- ting, facebook, second life) creates the possibility of providing software to sup- port social awareness in a range of ways. In this paper we focus on monitor- ing expectations and consider how a user who is not a programmer or logician might specify expectations to be monitored. We propose a novel approach where the user provides a collection of scenarios, and then candidate formulae are in- duced from the scenarios. The approach is applied to examples and appears to be promising.
Bookmarks Related papers MentionsView impact
Note: a considerably expanded version was subsequently published in a journal.
Stephen Cranefiel... more Note: a considerably expanded version was subsequently published in a journal.
Stephen Cranefield and Michael Winikoff. Verifying social expectations by model checking truncated paths. Journal of Logic and Computation, 2011, 21(6):1217-1256. doi:10.1093/logcom/exq055
Bookmarks Related papers MentionsView impact
In the literature on agent systems, the proactive behavior of agents is often modeled in terms of... more In the literature on agent systems, the proactive behavior of agents is often modeled in terms of goals that the agents pursue. We re- view a number of commonly-used existing goal types and propose a simple and general definition of goal, which unifies these goal types. We then give a formal and generic operationalization of goals by defining an abstract goal architecture, which describes the adoption, pursuit, and dropping of goals in a generic way. This operationalization is used to characterize the discussed goal types.
Bookmarks Related papers MentionsView impact
Abstract. A central problem in software maintenance is change propagation: given a set of primary... more Abstract. A central problem in software maintenance is change propagation: given a set of primary changes that have been made to software, what additional secondary changes are needed? Although many approaches have been proposed, automated change propagation is still a significant technical challenge in software engineering. In this paper we report on an evaluation of an agent-based approach for change propagation that works by repairing violations of well-formedness consistency rules in a design model. The results have shown that given a rea- sonable amount of primary changes, the approach is able to assist the designer by recommending feasible secondary change options that match the designer’s intentions.
Bookmarks Related papers MentionsView impact
Software maintenance is responsible for as much as two thirds of the cost of any software, and is... more Software maintenance is responsible for as much as two thirds of the cost of any software, and is consequently an important research area. In this paper we focus on the change propagation prob- lem: given a primary change that is made in order to meet a new or changed requirement, what additional, secondary, changes are needed? We build on previous work that has proposed to use a BDI (belief-desire-intention) agent framework to propagate changes by fixing violations of consistency constraints. One question that needs to be answered as part of this framework is how to select between different applicable (repair) plan instances to fix a given constraint violation? We address this issue by defining a suitable notion of repair plan cost that incorporates both conflict between plans, and synergies between plans. We then develop an algorithm, based on the notion of cost, that finds cheapest options and proposes them to the user.
Bookmarks Related papers MentionsView impact
Abstract. This paper describes how the Prometheus Design Tool (PDT) is used to support the Promet... more Abstract. This paper describes how the Prometheus Design Tool (PDT) is used to support the Prometheus methodology for designing agent systems. This is done by using an exemplar system that has been used previously in the literature, and is briefly described earlier in this volume. This paper presents the development of a design for this system using PDT. By using different tools and methodologies to design the same example system it is easier to observe the similarities and differ- ences between both the methodologies and the tools supporting them. Prometheus and PDT, like the other systems presented in this volume, has specific strengths and features that have been developed to support the design process. However it is also evident that there is a great deal of commonality across agent method- ologies that should give developers confidence that there is in fact an emerging agreed understanding as to the important aspects of designing and developing agent systems.
Bookmarks Related papers MentionsView impact
Uploads
Papers by Michael Winikoff
Akin Günay, Michael Winikoff, and Pinar Yolum. Dynamically Generated Commitment Protocols in Open Systems. Journal of Autonomous Agents and Multi-Agent Systems (JAAMAS). Volume 29, Number 2, pages 192-229. March 2015. doi:10.1007/s10458-014-9251-7
significantly improve teaching programming to novices.
To make this discussion more concrete, consider a personal as- sistant agent that manages a user’s calendar and tasks. One goal the agent may have is booking a meeting. This would typically be modelled as an achievement goal that aims to bring about a state where all required participants have the meeting in their calendar. However, in practice, diaries change, and we want to ensure that the meeting remains in participants’ diaries, and that should a key participant become unable to attend, a new time will be negoti- ated. This is not captured by an achievement goal. Rather, it is better modelled by a combined “achieve then maintain” goal which achieves a certain condition, and then maintains it over a certain time period. Another task that we might want the agent to under- take is to ensure that booking travel is not done until the budget is approved. Note that budget approval may be under the control (or perhaps just influence) of the agent, i.e. the agent may have plans for attempting to have the budget approved. Alternatively, it may be completely outside the agent’s control, in which case the agent can just wait for it to happen and then enable the travel booking process.
A number of papers have taken this line of research a step fur- ther by taking arbitrary Linear Temporal Logic (LTL) formulae as goals [1, 2, 12, 13, 16], rather than considering specific goal types. The advantage of this approach is that it does not restrict the goal types that can be used. However, a possible disadvantage is that it requires extensive alterations of a more basic agent programming framework, the practical implications of which are not yet clear.
Temporal logic is also used by MetateM [10], but it is used directly for agent execution, whereas we use temporal logic as a design framework for specifying goal types which are mapped to existing implementations of achieve and maintenance goals. Addi- tionally, MetateM requires a particular format for its rules: all rules are in one of the three forms: start → φ, or ψ → φ or ψ → φ where φ is a disjunction of literals, ψ is a conjunction of literals, and φ is a positive literal.
In this paper, we propose an approach that is somewhere in be- tween those focusing on a limited set of goal types and those in which arbitrary LTL formulae can be taken as goals. We propose an approach in which goals that are represented by relatively com- plex LTL formulae are operationalized by translating these LTL formulae to more basic achieve and maintain goals. The advantage of this approach is that the goal types can be integrated in existing
Rich Goal Types in Agent Programming
Mehdi Dastani Utrecht University The Netherlands [email protected]
M. Birna van Riemsdijk Delft University of Technology The Netherlands [email protected]
Michael Winikoff University of Otago
New Zealand [email protected]
Goals are central to the design and implementation of intelligent software agents. Much of the literature on goals and reasoning about goals in agent programming frameworks only deals with a limited set of goal types, typically achievement goals, and some- times maintenance goals. In this paper we extend a previously proposed unifying framework for goals with additional richer goal types that are explicitly represented as Linear Temporal Logic (LTL) formulae. We show that these goal types can be modelled as a com- bination of achieve and maintain goals. This is done by providing an operationalization of these new goal types, and showing that the operationalization generates computation traces that satisfy the temporal formula.
Stephen Cranefield and Michael Winikoff. Verifying social expectations by model checking truncated paths. Journal of Logic and Computation, 2011, 21(6):1217-1256. doi:10.1093/logcom/exq055
Akin Günay, Michael Winikoff, and Pinar Yolum. Dynamically Generated Commitment Protocols in Open Systems. Journal of Autonomous Agents and Multi-Agent Systems (JAAMAS). Volume 29, Number 2, pages 192-229. March 2015. doi:10.1007/s10458-014-9251-7
significantly improve teaching programming to novices.
To make this discussion more concrete, consider a personal as- sistant agent that manages a user’s calendar and tasks. One goal the agent may have is booking a meeting. This would typically be modelled as an achievement goal that aims to bring about a state where all required participants have the meeting in their calendar. However, in practice, diaries change, and we want to ensure that the meeting remains in participants’ diaries, and that should a key participant become unable to attend, a new time will be negoti- ated. This is not captured by an achievement goal. Rather, it is better modelled by a combined “achieve then maintain” goal which achieves a certain condition, and then maintains it over a certain time period. Another task that we might want the agent to under- take is to ensure that booking travel is not done until the budget is approved. Note that budget approval may be under the control (or perhaps just influence) of the agent, i.e. the agent may have plans for attempting to have the budget approved. Alternatively, it may be completely outside the agent’s control, in which case the agent can just wait for it to happen and then enable the travel booking process.
A number of papers have taken this line of research a step fur- ther by taking arbitrary Linear Temporal Logic (LTL) formulae as goals [1, 2, 12, 13, 16], rather than considering specific goal types. The advantage of this approach is that it does not restrict the goal types that can be used. However, a possible disadvantage is that it requires extensive alterations of a more basic agent programming framework, the practical implications of which are not yet clear.
Temporal logic is also used by MetateM [10], but it is used directly for agent execution, whereas we use temporal logic as a design framework for specifying goal types which are mapped to existing implementations of achieve and maintenance goals. Addi- tionally, MetateM requires a particular format for its rules: all rules are in one of the three forms: start → φ, or ψ → φ or ψ → φ where φ is a disjunction of literals, ψ is a conjunction of literals, and φ is a positive literal.
In this paper, we propose an approach that is somewhere in be- tween those focusing on a limited set of goal types and those in which arbitrary LTL formulae can be taken as goals. We propose an approach in which goals that are represented by relatively com- plex LTL formulae are operationalized by translating these LTL formulae to more basic achieve and maintain goals. The advantage of this approach is that the goal types can be integrated in existing
Rich Goal Types in Agent Programming
Mehdi Dastani Utrecht University The Netherlands [email protected]
M. Birna van Riemsdijk Delft University of Technology The Netherlands [email protected]
Michael Winikoff University of Otago
New Zealand [email protected]
Goals are central to the design and implementation of intelligent software agents. Much of the literature on goals and reasoning about goals in agent programming frameworks only deals with a limited set of goal types, typically achievement goals, and some- times maintenance goals. In this paper we extend a previously proposed unifying framework for goals with additional richer goal types that are explicitly represented as Linear Temporal Logic (LTL) formulae. We show that these goal types can be modelled as a com- bination of achieve and maintain goals. This is done by providing an operationalization of these new goal types, and showing that the operationalization generates computation traces that satisfy the temporal formula.
Stephen Cranefield and Michael Winikoff. Verifying social expectations by model checking truncated paths. Journal of Logic and Computation, 2011, 21(6):1217-1256. doi:10.1093/logcom/exq055