Date post: | 01-Apr-2015 |
Category: |
Documents |
Upload: | antwan-berkeley |
View: | 215 times |
Download: | 0 times |
Tropos: A Framework for Tropos: A Framework for Requirements-Driven Software DevelopmentRequirements-Driven Software Development
Jaelson Castro*
Centro de Informatica - CIN
Universidade Federal de Pernambuco - UFPE / Brazil
www.cin.ufpe.br/~jbc
* Visiting Assoc. Prof. at University of Toronto - Canada
Tropos: A Framework for Requirements-Driven Software Development 2
A bit of geographyA bit of geography
Tropos: A Framework for Requirements-Driven Software Development 3
OutlineOutline
Introduction
Early Requirements
Late Requirements
Architectural Design
Detailed Design
Implementation
Research Issues
Conclusion
Tropos: A Framework for Requirements-Driven Software Development 4
TeamTeam
University of Toronto: John Mylopoulos, Eric Yu, Manuel Kolp, Ariel Fuxman
University of York: Yves Lespérance
Universidade Federal de Pernambuco: Jaelson Castro
University of Trento/IRST: Paolo Bresciani, Paolo Giorgini, Fausto Giunchiglia, Anna Perini, Marco Pistore, Paolo Traverso
Warning: Work in Progress!!
TROPOS at the AGE of 15 months
Tropos: A Framework for Requirements-Driven Software Development 5
Software Development TechniquesSoftware Development Techniques Software development techniques offer concepts, tools and methods for
building software systems.
Traditionally, such techniques have been implementation-driven.
This means that the programming paradigm of the day dictated the design and requirements paradigms.
So, structured programming led to structured design and structured (requirements) analysis, while object-oriented programming led to object-oriented design and analysis.
Aligning the paradigms used for requirements, design and implementation makes perfect sense. But why start with implementation?
What would What would requirements-drivenrequirements-driven software development look software development look like??like??
Tropos: A Framework for Requirements-Driven Software Development 6
A Multi-Perspective View of SoftwareA Multi-Perspective View of Software We are working towards an agent-oriented software development
methodology, founded on the key concepts of actor, goal, (goal, task, resource) dependency, etc.
Software ca be viewed from four perspectives:
– OrganizationalOrganizational -- who are the relevant actors, what do they want? What are their obligations? …capabilities??
– IntentionalIntentional -- what are the relevant goals and how they interrelate? How are they being met? … by whom??
– Process-orientedProcess-oriented -- what are the relevant business/computer processes? Who is responsible for what?
– Object-orientedObject-oriented -- relevant objects
We are focusing on organizational and intentional perspectives because they are novel.
Tropos: A Framework for Requirements-Driven Software Development 7
Tropos*Tropos*
OntologyOntology
StructuringStructuring
Actors, social dependencies, goals, resources,...Actors, social dependencies, goals, resources,...
ApplicationApplicationareaarea
(Requirements-driven) Software development(Requirements-driven) Software development
Contexts (+generalization, aggregation, classification Contexts (+generalization, aggregation, classification and attribution)and attribution)
ToolsTools Software development, process analysis, enactment Software development, process analysis, enactment support, goal and softgoal analysissupport, goal and softgoal analysis
* TroposTropos, in Greek, means mannermanner (as in “manner of doing things”)
Guiding Principle: Push concepts as far down Guiding Principle: Push concepts as far down as possible (…and see what happens!)as possible (…and see what happens!)
Tropos: A Framework for Requirements-Driven Software Development 8
Where Do We Want to Be??Where Do We Want to Be??
Early
Early
requirements
requirements Late
Late
requirements
requirements
Architectural
Architectural
design
design Detaile
d
Detailed
design
design AgentAgent
Implementatio
n
Implementatio
n
i*i*
KAOSKAOS
ZZ
UML & co.UML & co.
i*i*
AUMLAUML
TROPOSTROPOS
GAIAGAIA
The GAP !!The GAP !!
Agent-OrientedAgent-Oriented ProgrammingProgramming
Tropos: A Framework for Requirements-Driven Software Development 9
Early vs Late RequirementsEarly vs Late Requirements
We need to distinguish between early phases of requirements analysis, when the analyst is trying to understand an organizational setting, from late phases when the analyst formulates a solution
OrganizationOrganization
SystemSystem
Organizational model
Contractual requirements
RequirementsRequirements
Tropos: A Framework for Requirements-Driven Software Development 10
Early vs Late RequirementsEarly vs Late Requirements
Early requirements amount to the definition of a search space (“scoping”) and a search among alternatives within that space.
Late requirements amount to refining, disambiguating and completing the description of the chosen alternative.
StructuredStructured and object-oriented analysesobject-oriented analyses are OK for late requirements.
Goal-oriented analysisGoal-oriented analysis is more appropriate for early requirements analysis because it focuses on the definition and exploration of a space of alternatives
Tropos: A Framework for Requirements-Driven Software Development 11
Goal-Oriented AnalysisGoal-Oriented Analysis
Goal-oriented analysis focuses on early requirements phases, when alternatives are being explored and evaluated.
During goal-oriented analysis, we start with initial goals such as “Increase Market Share”, “Handle Customer Orders”, “Buy Media Items”, “Easily maintainable system”, “Good performance” etc. and keep decomposing them until we have reduced them to alternative collections of design decisions each of which can satisfy the initial goals.
Initial goals may be organization- or system-oriented; they may also be conflicting, so the analysis must facilitate the discovery of tradeoffs and the search of the full space of alternatives, rather than a subset.
Tropos: A Framework for Requirements-Driven Software Development 12
Goal-Oriented Analysis is not New!Goal-Oriented Analysis is not New! Specification of composite systems -- [Feather87]
Goal-oriented elaboration of requirements -- ALBERT [Dubois94]
Goal-oriented requirements acquisition -- KAOS [Dardenne93]
Knowledge representation and reasoning in the design of composite systems -- Critter [Fickas92]
Goal-oriented requirements analysis -- Potts, Anton
i* and Non-Functional Requirements framework -- Yu, Chung
NATURE -- [Jarke93]
F3 -- [Bubenko93]
...and many others...
Tropos: A Framework for Requirements-Driven Software Development 13
An E-commerce Case StudyAn E-commerce Case Study Media taxonomy
– on-line catalog– DBMS
E-Shopping Cart– Check In– Buying– Check Out
Search Engine– catalog browser– Keywords– full-text
Secure– $ transactions– orders
Tropos: A Framework for Requirements-Driven Software Development 14
Early Requirements Analysis with TROPOSEarly Requirements Analysis with TROPOS
Understanding the problem by studying an existing organizational setting;
Output : Organizational model with relevant actors and respective goals.
Means-Ends Analysis & Functional AlternativesMeans-Ends Analysis & Functional Alternatives
Tropos: A Framework for Requirements-Driven Software Development 16
Late Requirements with TROPOSLate Requirements with TROPOS
The (software) system is now represented as one or more actors which participate in a strategic dependency model.
Resource, task and softgoal dependencies correspond naturally to functional and non-functional requirements.
Functional Goals generally operationalized during Late Requirements
Late Requirements (Strategic Relationships)Late Requirements (Strategic Relationships)
Specifications describing functional and non functional requirements for the system-to-be within its environment
Late Requirements (Strategic Rational Model)Late Requirements (Strategic Rational Model)
Medi@
Tropos: A Framework for Requirements-Driven Software Development 19
Assigning Responsabilities to SubactorsAssigning Responsabilities to Subactors
Availability
Adaptability
Tropos: A Framework for Requirements-Driven Software Development 20
Late Requirements with TROPOSLate Requirements with TROPOS
Leaving (some) goal dependencies between software system actors and other actors is a novelty. Traditionally, functional goals are “operationalized” during late requirements, and quality softgoals are either operationalized or “metricized”.
Removing goals early on leads to fragile software systems
Leaving goal dependencies with system actors as dependees makes sense whenever there is a foreseeable need for flexibility in the performance of a task on the part of the system.
– We have left 3 goals : Availability, Security and Adaptability
Tropos: A Framework for Requirements-Driven Software Development 21
Architectural DesignArchitectural Design
Global system architecture defined in terms of subsystems, interconnected through data, control and other dependencies.
3 Steps
– 1 Macro level : Architectural Styles (Organizational Styles) : “From Late Requirements to Architectural Design”
Vertical Integration, Pyramid, Joint Venture, Structure in 5, Bidding, Hierarchical Contracting, Co-optation, Takeover
– 2 Micro level : Patterns (Agent Community)
Contract-Net, Broker, Matchmaker,, Mediator, Monitor, Embassy, Wrapper, Master-Slave, ...
– 3 Assigning Actors to Agents, Positions, Roles: “From Actors to Agents”
In Progress
Tropos: A Framework for Requirements-Driven Software Development 22
Organizational Architectures (Macro Level)Organizational Architectures (Macro Level)
Joint VentureJoint Venture
Tropos: A Framework for Requirements-Driven Software Development 23
Quality Attributes for Agent SystemsQuality Attributes for Agent Systems
Correlation Catalogue Predictability Security Adaptability Cooperativity Competitivity Availability
Structure-in-5 HELP HELP HELP HELP HURT HELP
Pyramid MAKE MAKE MAKE MAKE BREAK MAKE
Join Venture HELP HELP MAKE HELP HURT HELP
Bidding BREAK BREAK MAKE HURT MAKE HURT
Takeover MAKE MAKE HURT MAKE BREAK HELP
Arm’s-Length HURT BREAK HELP HURT MAKE BREAK
Hierarchical Contracts HELP HELP HELP HELP HELP HELP
Vertical Integration HELP HELP HURT HELP HURT HELP
Co-optation HURT HURT MAKE MAKE HELP HURT
Tropos: A Framework for Requirements-Driven Software Development 24
A Joint-Venture E-commerce ArchitectureA Joint-Venture E-commerce Architecture
Tropos: A Framework for Requirements-Driven Software Development 25
Patterns (Micro level)Patterns (Micro level)
Contract-NetContract-Net
Tropos: A Framework for Requirements-Driven Software Development 26
Detailed DesignDetailed Design
The skills of all actors and their input/output data are refined using some specification technique.
As with detailed design for other techniques, the idea here is to specify completely the behaviour and I/O of each actor.
(A)UML [Odell00]
Plan Diagrams [Kinny96]
Tropos: A Framework for Requirements-Driven Software Development 27
Detailed Design: Shopping Cart ActorDetailed Design: Shopping Cart Actor
Tropos: A Framework for Requirements-Driven Software Development 28
Agent Interaction Protocol with AUMLAgent Interaction Protocol with AUML
The Checkout DialogueCustomer Shopping Cart
Tropos: A Framework for Requirements-Driven Software Development 29
Plan Diagram for checking out Plan Diagram for checking out
Tropos: A Framework for Requirements-Driven Software Development 30
Implementing Agent-Oriented SoftwareImplementing Agent-Oriented Software
Agents are implemented using some agent-oriented implementation platform (ex. JACK). Such platforms offer a communication protocol, possibly a negotiation protocol, perhaps some generic planning facility, a generic agent architecture, knowledge base management facilities, and more [Coburn00].
If there are dangling goal dependencies, I.e., goal dependencies for which no one has undertaken the responsibility to fulfill, build into the responsible agent skills for meeting these goals.
E.g., a communication goal might be met through repeated email, asking a third party to communicate etc.
If there are dangling softgoal dependencies, build into the responsible agent skills for addressing such softgoals.
E.g., a security agent would have a number of ways of meeting security goals
From TROPOS to JACK Java AgentsFrom TROPOS to JACK Java Agents
Tropos: A Framework for Requirements-Driven Software Development 32
Partial JACK Implementation for checking outPartial JACK Implementation for checking out
Tropos: A Framework for Requirements-Driven Software Development 33
FormalityFormalityEntity Order
Has orderId: Number, cust: Customer, date: Date,
items: SetOf [MediaItem]
Entity MediaItem
Has itemId: Number, itemTitle: String, description: Text, editor: String …
Actor Customer
Has customerId: Number, name: Name, address: Address, tel: PhoneNumber, …
Capable of MakeOrder, Pay, Browse, …
Goal order:Order buy:BuyMediaItems[order] (order.cust=self ◊Fulfil(buy))
Actor MediaShop
Has name: {MediaLive}, address: {“735 Yonge Street”}, phone#: 0461-762-883
Capable of Sell, Ship, SendInvoice, …
Goal ms:IncreaseMarketShare(Fulfil(ms))
GoalDependency BuyMediaItems
Mode Fulfil
Has order: Order
Defined ItemsReceivedOK(order)
Depender Customer
Dependee MediaShop
Necessary Fulfil( PlaceOrder(order))
SoftGoalDependency IncreaseMarketShare
Mode Maintain
Depender MediaShop
Dependee Customer
Necessary cust:Customer place:PlaceOrder[order] (order.cust=cust )
◊Fulfil(place))
Action MakeOrder
Performed By Customer
Refines PlaceOrder
Input cust : Customer, date : Date, items : SetOf [MediaItem]
Output order : Order
Post order.cust = cust order.date = date order.items items
Tropos: A Framework for Requirements-Driven Software Development 34
Research IssuesResearch Issues
An agent-oriented software development methodology with clear guidelines on what decisions are made when.
Applications of planning paradigms to agent-oriented software development.
Modeling (multi-agent) processes with coordination and exceptions.
Simulation and invariant analysis for agent and goal models.
Viability and workability analysis for dependencies.
Filling and managing positions and roles.
Goal and softgoal means-ends analysis.
Tropos: A Framework for Requirements-Driven Software Development 35
Research TasksResearch Tasks
Management of commitments and obligations, individual and global issues.
Case studies -- doing early and late requirements, architectural and detailed design in Tropos;
Modelling issues for late requirements, architectural design, detailed design: diagrams, annotations, formal specs;
An environment for building and analyzing Tropos specs;
…more...
Tropos: A Framework for Requirements-Driven Software Development 36
ConclusionsConclusions
From a Software Engineering perspective, this framework, however speculative, has advantages:
Leads to more flexible, robust and open software architectures;
Offers a coherent framework which encompasses all phases of software development, from early requirements to implementation
Is consistent with the next generation programming paradigm, I.e., agent-oriented programming, which is already gaining a foothold in key application areas, such as telecommunications, electronic commerce and web-based systems.
Tropos: A Framework for Requirements-Driven Software Development 37
...More Conclusions...More Conclusions
As well, from an Agent-Based Systems perspective the proposal
Suggests a comprehensive methodology for building agent-oriented software;
Offers a design dimension along which one decides how to accommodate tradeoffs among qualities such as flexibility, robustness, and performance.
Tropos: A Framework for Requirements-Driven Software Development 38
ReferencesReferences
[Bubenko93] Bubenko, J., “Extending the Scope of Information Modelling”, Proceedings Fourth International Workshop on the Deductive Approach to Information Systems and Databases, Costa Brava, 1993.
[Chung93] Chung, L., Representing and Using Non-Functional Requirements: A Process-Oriented Approach, PhD thesis, Department of Computer Science, University of Toronto, June 1993.
[Coburn00] Coburn, M., “Jack Intellignet Agents: User Guide version 2.0,” AOS Pty Ltd, 2000.
[Dardenne93] Dardenne, A., van Lamsweerde, A. and Fickas, S.,”Goal-Directed Requirements Acquisition”, in The Science of Computer Programming 20, 1993.
[Feather87] Feather, M., “Language Support for the Specification and Development of Composite Systems”, ACM Transactions on Programming Languages and Systems 9(2), 1987.
[Fickas92] Fickas, S. and Helm, R., “Knowledge Representation and Reasoming in the Design of Composite Systems”, IEEE Transactions on Software Engineering 18(6), June 1992.
[Greenspan84] Greenspan, S., Requirements Modelling: A Knowledge Representation Approach to to Software Requirements Definition, PhD thesis, Department of Computer Science, University of Toronto, 1994.
Tropos: A Framework for Requirements-Driven Software Development 39
References (cont’d)References (cont’d)
[Kinny96] Kinny, D and Georgeff M., “Modelling and Design of Multi-Agent System”, Proceedings of the Third International Workshop on Agent Theories, Architectures and Languages (ATAL-96).
[Odell00] Odell, J., Paranuk, V., and Bauer, B., “Extending UML for Agents”, Proceedings Agent-Oriented Information System Workshop at 17 National Conference on Artificial Intelligence, 2000.
[Singh99] Singh, M., “Synthesizing Requirements for Heterogeneous Autonomous Agents”, Autonomous Agents and Multi-Agent Systems, Kluwer, (to appear).
[Wooldridge00] Wooldridge, M., Jennings, N., Kinny, D., “The Gaia Methodology for Agent- Oriented Analysis and Design”, Journal of Autonomous Agents and Multi-Agent Systems, 3(3), 2000.
[Yu94] Yu, E., “Modelling Strategic Relationships for Process Reengineering”, PhD thesis, Department of Computer Science, University of Toronto, December 1994.
[Yu95] Yu, E., Du Bois, P., Dubois, E. and Mylopoulos, J., “From Organization Models to System Requirements: A ‘Cooperative Agents’ Approach”, Proceedings Third International Conference on Cooperative Information Systems, Vienna, May 1995.
Tropos: A Framework for Requirements-Driven Software Development 40
Tropos referencesTropos references
Mylopoulos, J. and Castro, J., “Tropos: A Framework for Requirements-Driven Software Development”, Brinkkemper, J. and Solvberg, A. (eds.), Information Systems Engineering: State of the Art and Research Themes, Springer-Verlag, June 2000.
Castro, J., Kolp, M. and Mylopoulos, J., Developing Agent-Oriented Information Systems for the Enterprise, Proceedings of the Second International Conference On Enterprise Information Systems (ICEIS00), Stafford, UK, July 2000.
Mylopoulos, J. and Fuxman, A. and Giorginei, P. “From Entities and Relationships to Social Actors and Dependencies”, Proceedings of the 19th International Conference on Conceptual Modeling, 2000.
Castro, J., Kolp, M. and Mylopoulos, J., “A Requirments Driven Development Methodology”, November 2000 (submitted for publication).
Kolp, M. and Mylopoulos, J., “Architectural Styles for Information Systems: An organizational Perspective”, November 2000 (submitted for publication).
http://www.cs.toronto.edu/~km/tropos
www.cs.toronto.edu/uml2001
www.cin.ufpe.br/~ler