Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Abstract
Patterns have recognised utility in software engineering
design and development processes.
The body of
knowledge of design and development of agent-based
systems is now sufficiently mature to be usefully
expressed as a pattern language. The essential elements
of agent-based decompositionautonomous agents,
relationships between agents, and organisational
structureslend themselves to a pattern-based
description. This paper describes an initiative currently
underway at Agentis Software to mine, document and
evolve a complete pattern language for agent-based
systems. These patterns define recurring agent-based
structures for both individual agents and multi-agent
system architectures. This paper discusses the software
engineering motivations for making this investment in
patterns by describing the strategic and pragmatic
motivations, the pattern mining process, how the
patterns are used in the design of agent-based solution
architectures, and our experiences in using and evolving
the pattern language.
Introduction
1/6
1.1
2/6
1.2
Our Approach
3/6
platform, it immediately began to attract local workarounds for unimplemented platform feature requests.
The resulting patterns provided valuable planning and
prioritisation input to the products roadmap. Over time,
we expect some of these patterns to be subsumed into the
Agentis product.
Agent design patterns sit at the next higher level of
abstraction and describe agent-based realisations of many
of the building blocks of enterprise applicationssmart
caches, filters, intelligent data structures, for example.
These are accompanied by a reference implementation in
the patterns repository that an agent developer can copy
and easily reuse. The developer typically designs with
these patterns and merges the reference implementations
in appropriate ways.
Patterns of agent-oriented system architecture sit at
the next level of abstraction in the solution space. These
include agent-based realisations of system-level
constructs that are applicable both within individual
agents (roles, layers and facades, for example) and
between agents in a multi-agent system (observers and
brokers, for example).
The pattern-mining effort does not stop there. As
experience in developing agent-based solutions
accumulates in particular markets or business domains,
recurring solution structures are identified, and clusters of
patterns are mined within specific solution domains.
Work has commenced on workflow, real time business
exception handling, and rule interpretation solution
domains, as well as in vertical markets such as insurance
underwriting. These pattern clusters, and their template
code modules, approach the utility of small, selfcontained frameworks, which designers combine and
extend to design agent architectures and assemble agent
solutions.
2.2
Sample patterns
4/6
2.3
Forces:
There are many validation, scheduling, sequencing
and selection scenarios where you need to apply a
number of business rules against a business data
structure.
A naive approach might be to combine the
individual validation rules into a single logical
expression. This approach restricts the ways you
can implement the rules to those expressions and
creates a maintenance problem because of the
complexity of the composed usage rules.
A more flexible approach is to think of each
individual business rule as a goal. Rules can run
the full range of complexity from a simple
expression implemented in a usage rule for one of
the goals plans, to a complex decision making
process implemented with multiple plans and subgoals. It also strongly encapsulates the
implementation of the rule, so that its evolution and
change over time will not impact other parts of the
agent.
The validation is then done by composing the
individual business rules (goals) under a common
validation goal, which provides simple rule
composition.
Forces:
In some web applications, navigation is dependent
upon what interactions or data have been provided
previously. As more information is collected from
the user, the application makes informed decisions
about narrowing or customising the presentation of
options. In an agent-based system, you want a
user interface agent controlling the user dialogue.
You need to represent a hierarchy of dependent
navigation or business rules, so that the agent can
control the dialog with the user and resolve to a set
of recommendations, options, or product offerings,
or calculation of results.
Consequences:
<< note on a disjunctive variant >>
<< note on an audit trail >>
<< note on the definition of rule>>
Consequences: I
<< note on asymmetric trees >>
<< note on instantiating multiple trees >>
<< note on data-driven trees >>
<< note on cycles >>
<< note on localisation considerations >>
2.4
5/6
community can review it, and so that its proposer can rethink and re-conceptualise it. Patlets exist to support
this early phase of a patterns existence.
A patlet is a cut-down pattern that states a name, the
problem, some (optional) bullet-pointed forces, and the
solution. It can be as simple or as detailed as the author
desires. The patlet sits on a shared portal and collects
comments. It takes three seconders from the community
to justify creation of a pattern from a patlet. When this
happens, the patlet (with the review input from its
seconders) is formally prototyped using the agent
platform and written up using the standard pattern
template. The new pattern is published and indexed but it
stays in Draft state.
The new draft pattern now surfaces in the pattern
repository. Users and reviewers accumulate comments
and feedback, which will quickly indicate its usefulness
or otherwise. When three instances of the patterns use
have been recorded, it transitions from Draft to Final
state. A patterns state is therefore the best indication of
its maturity.
A pattern in Final state may ultimately be retired, or
merged with other patterns, as the agent platform
changes. Patlets and patterns are never explicitly deleted,
as the life history of a pattern traces the progression of
design thinking about a particular problem and its
solutions.
3 Brief Assessment
The pattern language has found an enthusiastic
audience amongst Agentis consultants, partners, and
clients. Patterns are being used, sample implementations
reused, and feedback is accumulating on a shared services
portal. Judging from feedback, the decision to aim the
pattern language at enterprise Java developers has been
vindicatedso much so, that the pattern language is
being used to support technical pre-sales activities, a
benefit not anticipated.
In general, we have found that the patterns are larger
(in terms of the number of participating elements, the
description, and the reference implementation) and more
complex than traditional object-oriented patterns.
DECISION TREE is a good example of this. This may be
due to our definition of patternan OO traditionalist, for
example, might argue that DECISION TREE is conceptually
a component rather than a pattern. Our definition is
driven by achieving productivity through efficient reuse
of the reference implementation by project team
members.
Integration of the language with the Agentis product
roadmap is tight, and as new features are planned for
release, patterns must be updated. Pattern use is now a
valuable input to roadmap planning.
6/6
Conclusion
References