Abstract
Ph.D. (Computer Science)
The development of software systems is a relatively recent field of human endeavour. Even
so, it has followed a steady progression of dominant paradigms which have incrementally
improved the ease with which developers are able to express the logic and structure of their
systems. The initially unstructured era of free-form spaghetti code gave way to structured
programming in which the entry and exit points of functional units were well defined
through the creation of abstractions such as procedures, sub-routines and functions. The
problem of correctly associating data with the set of operations which are legal on this data
was addressed through the concept of encapsulation with the onset of object-oriented
programming. Object orientation also introduced a set of abstractions for safe code reuse
through inheritance and dynamic polymorphism as well as composition/aggregation and
delegation.
The agent-oriented software development paradigm, when viewed as an extension of
object orientation, adds the capacity of agent autonomy to an object, which allows it to
select for itself which of its operations it will execute at any point in time. In addition, the
separation between an agent and the environment within which it is embedded must be
well defined. Agent autonomy allows for the modelling and development of loosely coupled
systems with the capacity for complex emergent behaviour. The mapping of a given set of
environmental percepts to an agent's operation selection defines its agent function and
hence its emergent behaviour. Furthermore, agents may also be embedded into a shared
environment together with other agents forming a multi-agent system. The emergent
characteristics of such systems are defined not only through changes in environment state
but also via agent to agent interactions. Multi-agent systems are categorised into
cooperative or competitive based on whether all the agents within the system share a
common goal. An argument is presented that even within cooperative multi-agent systems
selfishness will emerge as a direct consequence of computational intractability. The core of
the argument centres on the finite nature of the computational resources available to an
agent which must be divided between the evaluation of the usefulness of other agent's
knowledge and intentions towards improving the collective utility of the system and directly
acting upon its own. As a direct result of the halting problem it is impossible for an agent to
ascertain in general whether another agent's plans are even feasible (i.e. will result in the
system reaching a goal state). As a direct consequence of such a limitation agents will in
general favour their own courses of action over those of others and hence an emergent
selfishness occurs even in ostensibly cooperative systems...