A Requirements-Driven Development Methodology *
Jaelson Castro1, Manuel Kolp2 and John Mylopoulos2
1
Centro de Informática, Universidade Federal de Pernambuco, Av. Prof. Luiz Freire S/N,
Recife PE, Brazil 50732-970†
jbc@cin.ufpe.br
2Department of Computer Science, University of Toronto, 10 King’s College Road, Toronto
M5S3G4, Canada
{mkolp,jm}@cs.toronto.edu
Abstract. Information systems of the future will have to better match their
operational organizational environment. Unfortunately, development
methodologies have traditionally been inspired by programming concepts, not
organizational ones, leading to a semantic gap between the system and its
environment. To reduce as much as possible this gap, this paper proposes a
development methodology named Tropos which is founded on concepts used to
model early requirements. Our proposal adopts the i* organizational modeling
framework [18], which offers the notions of actor, goal and (actor) dependency,
and uses these as a foundation to model early and late requirements,
architectural and detailed design. The paper outlines Tropos phases through an
e-business example. The methodology seems to complement well proposals for
agent-oriented programming platforms.
1 Introduction
Information systems have traditionally suffered from an impedance mismatch. Their
operational environment is understood in terms of actors, responsibilities, objectives,
tasks and resources, while the information system itself is conceived as a collection of
(software) modules, entities (e.g., objects, agents), data structures and interfaces. This
mismatch is one of the main factors for the poor quality of information systems, also
the frequent failure of system development projects.
One cause of this mismatch is that development methodologies have traditionally
been inspired and driven by the programming paradigm of the day. This means that
the concepts, methods and tools used during all phases of development were based on
those offered by the pre-eminent programming paradigm. So, during the era of
structured programming, structured analysis and design techniques were proposed
[9,17], while object-oriented programming has given rise more recently to object-
oriented design and analysis [1,15]. For structured development techniques this meant

*
The Tropos project has been partially funded by the Natural Sciences and Engineering
Research Council (NSERC) of Canada, and Communications and Information Technology
Ontario (CITO), a centre of excellence, funded by the province of Ontario.
†
This work was carried out during a visit to the Department of Computer Science, University
of Toronto. Partially supported by the CNPq – Brazil under grant 203262/86-7.

that throughout software development, the developer can conceptualize the system in
terms of functions and processes, inputs and outputs. For object-oriented
development, on the other hand, the developer thinks throughout in terms of objects,
classes, methods, inheritance and the like.
Using the same concepts to align requirements analysis with system design and
implementation makes perfect sense. For one thing, such an alignment reduces
impedance mismatches between different development phases. Moreover, such an
alignment can lead to coherent toolsets and techniques for developing system (and it
has!) as well, it can streamline the development process itself.
But, why base such an alignment on implementation concepts? Requirements
analysis is arguably the most important stage of information system development.
This is the phase where technical considerations have to be balanced against social
and organizational ones and where the operational environment of the system is
modeled. Not surprisingly, this is also the phase where the most and costliest errors
are introduced to a system. Even if (or rather, when) the importance of design and
implementation phases wanes sometime in the future, requirements analysis will
remain a critical phase for the development of any information system, answering the
most fundamental of all design questions: “what is the system intended for?”
Information systems of the future like ERP, Knowledge Management or e-business
systems should be designed to match their operational environment. For instance,
ERP systems have to implement a process view of the enterprise to meet business
goals, tightly integrating all functions from the operational environment. To reduce as
much as possible this impedance mismatch between the system and its environment,
we outline in this paper a development framework, named Tropos, which is
requirements-driven in the sense that it is based on concepts used during early
requirements analysis. To this end, we adopt the concepts offered by i* [18], a
modeling framework offering concepts such as actor (actors can be agents, positions
or roles), as well as social dependencies among actors, including goal, softgoal, task
and resource dependencies. These concepts are used for an e-commerce example‡ to
model not just early requirements, but also late requirements, as well as architectural
and detailed design. The proposed methodology spans four phases:
• Early requirements, concerned with the understanding of a problem by studying an
organizational setting; the output of this phase is an organizational model which
includes relevant actors, their respective goals and their inter-dependencies.
• Late requirements, where the system-to-be is described within its operational
environment, along with relevant functions and qualities.
• Architectural design, where the system’s global architecture is defined in terms of
subsystems, interconnected through data, control and other dependencies.
• Detailed design, where behaviour of each architectural component is defined in
further detail.
The proposed methodology includes techniques for generating an implementation
from a Tropos detailed design. Using an agent-oriented programming platform for the
implementation seems natural, given that the detailed design is defined in terms of

‡
Although, we could have included a simpler (toy) example, we decided to present a
realistic e-commerce system development exercise of moderate complexity [6].