This research aims to develop a new approach to software engineering using intentional and agent-oriented concepts. Intentional concepts such as goals, beliefs, abilities, and commitments will be used to guide and constrain software engineering activities such as requirements analysis, architectural design, testing, and maintenance. Knowing exactly which goals each unit of software must satisfy will clarify important tradeoffs such as among reliability, performance, flexibility, etc. Libraries of design knowledge can be used to semi-automatically guide designers through the myriad of decisions and steps, while at the same time recording them for future reference. When changes are required, these knowledge structures provide the necessary pathways to retrace the design steps and to recover the original context. One can then incrementally explore the new space of alternatives, evaluate implications, and take necessary action.
The agent concept provides a focal point for accountability and responsibility
for coping with the complexity of software systems both during design and
during execution. An agent is an encapsulation of goals, know-how,
and resources. Local decisions and actions can be private so that
only significant results are presented to the outside. Relationships among
agents are expressed in terms of what they expect each other to accomplish.
Major decisions in software design will be about setting up the right relationships
among agents (software units) to achieve a viable software system from
various points of view, e.g, functionality, robustness, fast time-to-market,
etc. Intentional and agent-oriented modelling allow complex systems
to be described abstractly so as to hide details such as data and control
The research will produce new languages, methods, tools, and samples of reusable knowledge.
Software development is a knowledge-intensive activity. Current software representations – from programming languages to specifications to requirements models -- are non-intentional. They are meant to record the results of software work, but not the process or the reasoning behind them. Design intents and rationales are currently documented (if at all) in informal text and diagrams, which are hard to manipulate, update, validate, or reuse. This research aims to develop a framework for software engineering in which the intentional dimension is taken fully into account and supported by languages, methods, tools, and libraries of reusable knowledge.
Keeping track of all the reasoning behind software can be an overwhelming task. Advances in conceptual modelling and repository technologies can go a long way in helping manage the complex bodies of knowledge. This research will introduce the concept of “agent” (or actor) as a modelling construct to encapsulate intentionality. Agents may have internal goals, methods to achieve goals, and resources. They have autonomy but their decisions and actions are constrained by social relationships with other agents. Agents depend on each other for goals to be achieved, tasks to be performed, and resources to be furnished. Agent-oriented modelling thus treats software at a higher-level of abstraction then in current models and languages (e.g., UML or architectural description languages). Software is therefore not just executable code, nor just designs and specifications and requirements expressed in today’s non-intentional languages, but also the rich interconnected web of intentional relationships within and among agents.
By making the reasoning relative to agents, a high degree of incompleteness and hiding can be allowed since the interests and goals of agents provide criteria for what needs to be made explicit, internally or externally (namely, what is strategically significant to each agent).
The proposed framework will provide languages for intentional and agent-oriented modelling at the various levels of SE development. The initial plan is to focus on requirements exploration, requirements definition, architectural design, detailed design, run-time monitoring, as well as linkages to high-level business goals. Evolution and change support will be addressed throughout. At each stage, the relevant software units (and their design intents) will be modelled as agents and their reasoning with respect to their goals and external relationships. Relationships among software units will be modelled in terms of what they expect each other to achieve, rather than as data or control flows.
The languages will share a common core of features derived from i*. These will include types of external dependencies such as goal-, task-, resource-, and softgoal-dependencies, and different levels of commitment. The reasoning within each agent will be supported by means-ends and task-decomposition relationships. The modelling of relationships among softgoals will build on extensions to the NFR framework for dealing with non-functional requirements [CNYM00]. The basic types of reasoning will include assessments of ability, viability, believability, opportunity, and vulnerability [Yu95]. The impact of changes will be propagated using a qualitative reasoning framework. Different types of agent abstractions provide different kinds of controlled propagation across agent boundaries. Various classes of agents will be defined. For example, in i* the generic term for intentional agents is “actor”. Physical agents are then differentiated from the more logical notions of roles and positions.
Beyond the common core, adaptations will be needed to address specific needs at the different stages of SE, and the types of reasoning that occur at those stages. For example, specialized types of dependencies and actors will be defined for detailed design vs. those for architectural design. The languages will have diagrammatic notations as well as formal properties to support analysis.
Methodologies will be developed to guide the use of the representational schemes. These will include modelling at each level, linking across levels, as well as mappings to conventional non-intentional models (e.g., UML) where appropriate. The languages and methodologies will be supported by tools that provide knowledge base management support as well as interactive reasoning support.
Most of the computational support will only be semi-automated since much of software engineering work still require human judgement and experience. However, knowledge that can be reused across projects can be codified into generic methods and rules and stored in knowledge libraries. These will be invoked as assistants during particular SE tasks. Other approaches for reusing knowledge, e.g., case-based reasoning, will also be investigated.
In the proposed framework, agents and other intentional concepts are used for modelling both the software and the software engineering processes and activities. This approach treats the design and decision making processes leading up to the software and the machine-executable software itself as a conceptual continuum. Activities may be shifted to automation when the implementation technology is capable of handling them, or back to human decision making otherwise. A longer-term objective is to provide a software engineering paradigm that supports the smooth co-existence of conventional software and “intelligent agent” software technology.
The approach also provides a vehicle for more coherently deploying and
linking the diverse SE techniques available today. The agent concept
allows specialized activities (e.g., verification using formal methods)
to be pursued in a circumscribed context, guided by local goals. Selected
results can then be propagated to relevant actors (software units or processes)
who depend on these results.