Towards requirements-driven information systems engineering: the Tropos project

Question

Towards requirements-driven information systems engineering: the Tropos project (answer the following questions)

1. Search and summarize what the TROPOS project is?

2. What are the key challenges of this effort?

3.How can the software development model address (good or poor) towards organizational model of actor and goal dependency?

4. Discuss the key considerations of this effort.

NOTE: Tropos explores multiple phases through an e-business example, and sketches a formal language which underlies the methodology and is intended to support formal analysis. The methodology seems to complement well proposals for agent-oriented programming platforms.

Explanation / Answer

1.) Summary of TROPOS project.

Existing software development methodologies (object-oriented, structured or otherwise) have traditionally been inspired by programming concepts, not organizational ones, leading to a semantic gap between the software system and its operational environment. To reduce this gap, a software development methodology named Tropos is proposed which is founded on concepts used to model early requirements. The proposal adopts the i organizational modeling framework, 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.  Distinguishing it from other agent-oriented modeling approaches, Tropos is characterised by three key aspects :

1.) Tropos deals with all phases of system development (requirements analysis, system design, and implementation), adopting a uniform and homogeneous way based on the notion of agents and all the related mentalistic notions, such as actors, goals, tasks, resources, and intentional dependencies.

2. ) Tropos pays particular attention to early requirements, emphasising the need to understand not only what organisational goals are required, but also how and why the intended system would meet these organisational goals. This allows for a more refined analysis of system dependencies, leading to a better treatment not only of the system’s functional requirements, but also of its non-functional requirements such as security, reliability, and performance .

3.) Tropos is based on the idea of building a model of the system that is incrementally refined and extended from a conceptual level to executable artefacts by means of a sequence of transformational steps at the goal, softgoal and actor level [1,2]. Such transformations allow developers to move towards the final complete model by progressively introducing more structure and details.

2.) Challenges

The following key challenges will need to be answered to allow the effective and widespread use of Tropos:

(a) what modeling constructs should be used at which stage of the development process.

(b) what amount of detail should be provided in a model.

(c) how should the models be mapped between different stages?

3. and 4.)

Software development techniques 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, while objectoriented
programming has given rise more recently to object-oriented design and analysis. For
structured development techniques this meant that throughout software development, the developer can
conceptualize her software system in terms of functions and processes, inputs and outputs. For objectoriented
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 software design and implementation makes
perfect sense. For one thing, such an alignment reduces impedance mismatches between different
development phases. Think what it would be like to take the output of a structured analysis task, consisting
of data flow and entity-relationship diagrams, and try to produce out of it an object-oriented design!
Moreover, such alignment can lead to coherent toolsets and techniques for developing software (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 software development. This is the phase where technical considerations have to be
balanced against social and personal ones. Not surprisingly, this is also the phase where the most and
costliest errors are introduced to a software system. Even if (or rather, when) the importance of design and
implementation phases wanes sometime in the future -- thanks to COTS, software reuse and the like --
requirements analysis will remain a critical phase for the development of any software system, answering
the most fundamental of all design questions: “what is the system intended for?”

The Tropos methodology covers five main software development stages:
1. During early requirements analysis, developers are concerned with understanding
a problem by studying an existing organisational setting. This involves the identification
of the domain stakeholders, and modelling them as social actors. The output
of this phase is an organisational model, which includes relevant actors, their goals,
and their respective dependencies.
2. During late requirements analysis, the system-to-be is introduced a another actors,
and specified within its operational environment, together with relevant functions
and qualities. The output of this stage is a revised model which includes the system,
any relevant actors, and their respective dependencies.
3. During architectural design, the system’s global architecture is defined in terms of
additional system actors, interconnected via data and control dependencies. The final
output of this stage is a set of software agents corresponding to the actors of the
system, each characterised by its specific capabilities.
4. During detailed design, each architectural component is defined in further detail in
terms of inputs, outputs, control, and other aspects such as security.
5. During implementation, the actual implementation of the system components takes
place according to the specification produced during detailed design. It is worth
mentioning that Tropos (similar to other agent-oriented methodologies) does not
force the use of an agent platform as the implementation technology

Related Questions

Navigate

• Browse (All)
• Browse T
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.