This document discusses use case modeling and analysis. It provides an overview of use cases, actors, relationships between use cases, and how to develop a use case model. Key steps include identifying actors and use cases, creating a use case diagram, describing use cases, and prioritizing use cases. The document uses examples of an ATM system and hotel information system to illustrate use case concepts.
The document discusses use case modeling. It defines use cases as narrative descriptions of domain processes in a structured prose format. It describes key concepts like actors, scenarios, and the relationships between use cases such as include and extend. It provides guidelines for writing use cases, including identifying the system boundary, primary actors, and their goals to derive use cases. It also describes different styles and levels of detail for writing use cases.
The document discusses use case modeling and provides several examples. It describes key concepts like actors, use cases, relationships between use cases, and multiplicity. It then summarizes 4 examples - an airport check-in system, bank ATM, online library catalog, and credit card processing. The examples illustrate how use cases model systems and interactions between actors and the system.
The chapter discusses use case modeling for system requirements. It defines key concepts like actors, use cases, use case diagrams and narratives. The benefits of use case modeling include capturing functional requirements, communicating with users, and establishing test cases. Use case modeling provides a user-centered approach to defining a system's scope and functionality.
The document provides guidance on developing use case models for a system. It defines key concepts like actors, use cases, include and extend relationships. It explains that use cases describe interactions between actors and the system to achieve goals. The document also provides examples of use case diagrams and descriptions to illustrate how to identify actors and use cases, and describe typical and alternative flows and exceptions. It emphasizes that use cases specify expected behavior from the user's perspective without detailing implementation.
The document describes how to determine and calculate cyclomatic complexity for a code sample that uses the Euclid's algorithm to compute the greatest common divisor (GCD) of two numbers. It provides three methods to calculate the cyclomatic complexity of the code: 1) using the number of nodes and edges in the control flow graph, 2) using the number of non-overlapping areas, and 3) using the number of decision statements and loops. The cyclomatic complexity is determined to be 3 using all three methods. The document also includes an example of creating a software requirements specification (SRS) document for a banking system application using use case diagrams, state diagrams, and activity diagrams in Star UML.
The document summarizes a chapter about use case modeling. It describes use cases and actors, relationships between use cases, and use case descriptions. Use case modeling involves identifying functional requirements, drawing diagrams showing actors and use cases, and writing use case descriptions in a conversational style to document interactions between actors and the system. Relationships like include, extend, and generalization are used to show how use cases relate to each other.
This document discusses the application of machine learning algorithms for fraud detection in the banking sector. It proposes using Classification and Regression Tree (CART), AdaBoost, LogitBoost, and Bagging algorithms to classify banking data and detect fraud. An experiment is conducted to analyze the performance of these algorithms on a banking data set. The results show that the Bagging algorithm has the lowest misclassification rate, indicating it performs better than the other algorithms at classifying banking data for fraud detection. In conclusion, the Bagging algorithm is deemed the best performing of the meta-learning algorithms analyzed for fraud detection in banking data.
The document discusses the development of a banking system application. It provides an overview of banks and their services, defines the problem of developing such an application, and analyzes the requirements and proposed solution. The application would allow customers to submit deposits, view accounts, and manage balances. It will use a username and password for login. Transactions will be stored securely in files. The front end will be developed in Turbo C++ for Windows.
The document discusses use case modeling. It defines use cases as narrative descriptions of domain processes in a structured prose format. It describes key concepts like actors, scenarios, and the relationships between use cases such as include and extend. It provides guidelines for writing use cases, including identifying the system boundary, primary actors, and their goals to derive use cases. It also describes different styles and levels of detail for writing use cases.
The document discusses use case modeling and provides several examples. It describes key concepts like actors, use cases, relationships between use cases, and multiplicity. It then summarizes 4 examples - an airport check-in system, bank ATM, online library catalog, and credit card processing. The examples illustrate how use cases model systems and interactions between actors and the system.
The chapter discusses use case modeling for system requirements. It defines key concepts like actors, use cases, use case diagrams and narratives. The benefits of use case modeling include capturing functional requirements, communicating with users, and establishing test cases. Use case modeling provides a user-centered approach to defining a system's scope and functionality.
The document provides guidance on developing use case models for a system. It defines key concepts like actors, use cases, include and extend relationships. It explains that use cases describe interactions between actors and the system to achieve goals. The document also provides examples of use case diagrams and descriptions to illustrate how to identify actors and use cases, and describe typical and alternative flows and exceptions. It emphasizes that use cases specify expected behavior from the user's perspective without detailing implementation.
The document describes how to determine and calculate cyclomatic complexity for a code sample that uses the Euclid's algorithm to compute the greatest common divisor (GCD) of two numbers. It provides three methods to calculate the cyclomatic complexity of the code: 1) using the number of nodes and edges in the control flow graph, 2) using the number of non-overlapping areas, and 3) using the number of decision statements and loops. The cyclomatic complexity is determined to be 3 using all three methods. The document also includes an example of creating a software requirements specification (SRS) document for a banking system application using use case diagrams, state diagrams, and activity diagrams in Star UML.
The document summarizes a chapter about use case modeling. It describes use cases and actors, relationships between use cases, and use case descriptions. Use case modeling involves identifying functional requirements, drawing diagrams showing actors and use cases, and writing use case descriptions in a conversational style to document interactions between actors and the system. Relationships like include, extend, and generalization are used to show how use cases relate to each other.
This document discusses the application of machine learning algorithms for fraud detection in the banking sector. It proposes using Classification and Regression Tree (CART), AdaBoost, LogitBoost, and Bagging algorithms to classify banking data and detect fraud. An experiment is conducted to analyze the performance of these algorithms on a banking data set. The results show that the Bagging algorithm has the lowest misclassification rate, indicating it performs better than the other algorithms at classifying banking data for fraud detection. In conclusion, the Bagging algorithm is deemed the best performing of the meta-learning algorithms analyzed for fraud detection in banking data.
The document discusses the development of a banking system application. It provides an overview of banks and their services, defines the problem of developing such an application, and analyzes the requirements and proposed solution. The application would allow customers to submit deposits, view accounts, and manage balances. It will use a username and password for login. Transactions will be stored securely in files. The front end will be developed in Turbo C++ for Windows.
The document discusses use case diagrams in object oriented design and analysis. It defines use cases as descriptions of system functionality from a user perspective. Use case diagrams depict system behavior, users, and relationships between actors, use cases, and other use cases. The key components of use case diagrams are described as actors, use cases, the system boundary, and relationships. Common relationships include association, extend, generalization, uses, and include. An example use case diagram for a cellular telephone is provided to illustrate these concepts.
Credit Card Fraud Detection Using Unsupervised Machine Learning AlgorithmsHariteja Bodepudi
This document summarizes a research paper that uses unsupervised machine learning algorithms to detect credit card fraud. It describes how credit card fraud has increased with the rise of online shopping and payments. Unsupervised algorithms are well-suited for this task since labeled fraud data can be difficult to obtain. The paper tests Isolation Forest, Local Outlier Factor, and One Class SVM on a credit card transaction dataset to find anomalies (fraudulent transactions). Isolation Forest achieved the highest accuracy at 99.74%, slightly outperforming Local Outlier Factor, while One Class SVM had much lower accuracy. The paper concludes unsupervised algorithms are effective for anomaly detection tasks like credit card fraud detection.
This document provides a project report for the completion of a 4th semester mini project on online shopping. It includes an introduction to the project, existing system analysis and drawbacks, proposed system details, feasibility study, requirements analysis, system design specification, and planned testing. The project aims to develop an online shopping system that allows customers to shop from home, provides lower prices due to reduced overhead costs, and offers free home delivery. It will use JSP for the front end and MySQL for the back end.
This chapter discusses use case modeling techniques including developing detailed use case descriptions, activity diagrams, system sequence diagrams (SSDs), and integrating requirements models. It covers writing use case descriptions with elements like name, scenario, triggering event, actors, flow of activities, and exceptions. Activity diagrams and SSDs can show the flow of activities and inputs/outputs for a use case. Relating use cases to domain classes through CRUD analysis helps ensure all requirements are addressed.
The document discusses systems analysis activities for the RMO Consolidated Sales and Marketing System project. It describes investigating system requirements, which is core process 3 of the SDLC. This includes defining functional and non-functional requirements, identifying stakeholders, gathering information through techniques like interviews and questionnaires, and using models like UML activity diagrams to document workflows and requirements. The RMO project is used as a running example to illustrate these analysis concepts and techniques.
Use Case Modeling in Software Development: A Survey and TaxonomyEswar Publications
Identifying use cases is one of the most important steps in the software requirement analysis. This paper makes a literature review over use cases and then presents six taxonomies for them. The first taxonomy is based on the level of functionality of a system in a domain. The second taxonomy is based on primacy of functionality and the third one relies on essentialness of functionality of the system. The fourth taxonomy is concerned with supporting of functionality. The fifth taxonomy is based on the boundary of functionality and the sixth one is related to generalization/specialization relation. Then the use cases are evaluated in a case study in a control command police system. Several guidelines are recommended for developing use cases and their refinement, based on some
practical experience obtained from the evaluation.
1. Use case diagrams show functional requirements without specifying order, data or control flow. Straight lines connect actors to use cases.
2. Actor generalization and use case extension/inclusion are shown. Extension improves on a use case, inclusion completes tasks for another use case.
3. External systems that use the system under design are represented, without data flow. Their placement is not critical.
Use case diagrams describe interactions between actors and a system to accomplish goals. A use case diagram typically includes:
1) Actors that interact with the system from outside, such as users or other systems. Common actor types are primary actors whose goals are fulfilled by the system and supporting actors that provide services.
2) Use cases that represent functions or tasks performed by the system. They are connected to relevant actors and may have relationships like include and extend.
3) Relationships between use cases like include, which shows a use case incorporating another, and extend, where a use case optionally extends another.
Use case diagrams provide an overview of a system's functions and how outside actors interact with them at a
Banknote design management should invest in user needs. When cash is no longer an attractive payment instrument,
banknotes will disappear. User needs will lead to other design requirements as applied today. Furthermore, banknote
designers should focus first of all on the User Interface Functions, instead of spending their creativity to User
Experience Functions like connecting to a main image.
Operationalize deep learning models for fraud detection with Azure Machine Le...Francesca Lazzeri, PhD
Recent advancements in computing technologies along with the increasing popularity of ecommerce platforms have radically amplified the risk of online fraud for financial services companies and their customers. Failing to properly recognize and prevent fraud results in billions of dollars of loss per year for the financial industry. This trend has urged companies to look into many popular artificial intelligence (AI) techniques, including deep learning for fraud detection. Deep learning can uncover patterns in tremendously large datasets and independently learn new concepts from raw data without extensive manual feature engineering. For this reason, deep learning has shown superior performance in domains such as object recognition and image classification.
Although, neural networks have been used for fraud detection for decades, recent advancements in computing technologies along with large volumes of data available today have dramatically improved the effectiveness of these techniques. Using a sample dataset that contains transactions made by credit cards in September 2013 by European cardholders, Francesca Lazzeri and Jaya Mathew explain how to build, deploy, and operationalize a deep learning model to identify and prevent fraud, using Azure Machine Learning Workbench to show the main steps in the operationalization process (from data ingestion to consumption) and the Keras deep learning library with Microsoft Cognitive Toolkit CNTK as the backend.
Presents a more expansive view of "stakeholders" in systems design, specifically beyond purely human notions. Produced for use by the IEEE P7000 working group "Model Process for Addressing Ethical Concerns During System Design."
The document discusses use case modeling and provides information on key concepts:
- A use case describes interactions between a system and external users (actors) to achieve a goal. It specifies system behavior but not implementation.
- Key components of use case modeling include actors, use cases, relationships between use cases like inclusion and extension, and use case descriptions.
- Use cases capture functional requirements while use case descriptions elaborate different scenarios through structured text or pseudocode. Organizing use cases into packages supports generalization and specialization.
The document discusses techniques for dynamic analysis and modeling in object-oriented systems. It describes developing use case scenarios, system-level sequence diagrams, subsystem-level diagrams, three-tier sequence diagrams involving boundary, control and entity objects, and statechart diagrams for control objects. The goal is to transform requirements into an implementation through modeling object interactions and behavior.
The document discusses requirements definition and system modeling. It defines requirements as conditions or capabilities needed by stakeholders to solve problems or achieve objectives. Requirements should be defined at three levels - business, user, and product. Business requirements define problems to be solved or opportunities addressed. User requirements describe functionality from the user perspective. Product requirements specify functionality that must be built into the software. System modeling helps understand functionality and communicate with customers using models from different perspectives. Requirements definition and system modeling lay the foundation for software development.
The document discusses use case modeling and UML diagrams. It provides an overview of commonly used UML diagrams such as use case diagrams, activity diagrams, class diagrams, sequence diagrams, and collaboration diagrams. It then describes use cases, use case diagrams, and relationships between use cases including include, extend, and generalize relationships.
Welcome to my series of articles on Unified Modeling Language. This is "Session 2 – Use Case UML" of the series. I have covered Use Case Scenario, Use Case Narrative and Use Case Model in this session.
Please view my other documents where I have covered each UML diagram with examples
A use case describes interactions between an actor and a system to achieve a goal. It represents a discrete unit of functionality provided by the system. The key components of a use case include the actor, system boundary, and use cases within the boundary. An actor can be a person or external system. A use case should be written from the perspective of the actor and describe the measurable value or objective the actor wants to achieve through their interaction with the system. Use case diagrams are used during requirements gathering and analysis to identify the functional scope of the system and external factors that influence it from the viewpoint of users, not developers.
Use case modeling involves describing how users will interact with a system to achieve goals. A use case represents a dialog between a user and the system, specifying what information must pass between them without detailing the system's internal workings. Each use case should have a name that includes a verb describing the user's goal. Actors represent people or systems that interact with the system-to-be to accomplish responsibilities. Sequence diagrams visually depict the information exchanged between actors and the system in specific use case scenarios.
Financial Analysis of Berlin Brandenburg AirportTotal of 3000 woChereCheek752
This document provides a template and guidelines for writing a Software Requirements Specification (SRS) to document the requirements for a software project. The SRS template includes 10 sections: Introduction, Overall Description, Use Case Diagram and Descriptions, User Interfaces, Other Nonfunctional Requirements, Other Requirements, Data Flow Diagram, Functional Requirements, Sequence Diagram, and Class Diagram. The document explains the purpose and provides examples of the content expected in each section to clearly define the requirements, features, interfaces, and design of the software system.
The document discusses use case diagrams in object oriented design and analysis. It defines use cases as descriptions of system functionality from a user perspective. Use case diagrams depict system behavior, users, and relationships between actors, use cases, and other use cases. The key components of use case diagrams are described as actors, use cases, the system boundary, and relationships. Common relationships include association, extend, generalization, uses, and include. An example use case diagram for a cellular telephone is provided to illustrate these concepts.
Credit Card Fraud Detection Using Unsupervised Machine Learning AlgorithmsHariteja Bodepudi
This document summarizes a research paper that uses unsupervised machine learning algorithms to detect credit card fraud. It describes how credit card fraud has increased with the rise of online shopping and payments. Unsupervised algorithms are well-suited for this task since labeled fraud data can be difficult to obtain. The paper tests Isolation Forest, Local Outlier Factor, and One Class SVM on a credit card transaction dataset to find anomalies (fraudulent transactions). Isolation Forest achieved the highest accuracy at 99.74%, slightly outperforming Local Outlier Factor, while One Class SVM had much lower accuracy. The paper concludes unsupervised algorithms are effective for anomaly detection tasks like credit card fraud detection.
This document provides a project report for the completion of a 4th semester mini project on online shopping. It includes an introduction to the project, existing system analysis and drawbacks, proposed system details, feasibility study, requirements analysis, system design specification, and planned testing. The project aims to develop an online shopping system that allows customers to shop from home, provides lower prices due to reduced overhead costs, and offers free home delivery. It will use JSP for the front end and MySQL for the back end.
This chapter discusses use case modeling techniques including developing detailed use case descriptions, activity diagrams, system sequence diagrams (SSDs), and integrating requirements models. It covers writing use case descriptions with elements like name, scenario, triggering event, actors, flow of activities, and exceptions. Activity diagrams and SSDs can show the flow of activities and inputs/outputs for a use case. Relating use cases to domain classes through CRUD analysis helps ensure all requirements are addressed.
The document discusses systems analysis activities for the RMO Consolidated Sales and Marketing System project. It describes investigating system requirements, which is core process 3 of the SDLC. This includes defining functional and non-functional requirements, identifying stakeholders, gathering information through techniques like interviews and questionnaires, and using models like UML activity diagrams to document workflows and requirements. The RMO project is used as a running example to illustrate these analysis concepts and techniques.
Use Case Modeling in Software Development: A Survey and TaxonomyEswar Publications
Identifying use cases is one of the most important steps in the software requirement analysis. This paper makes a literature review over use cases and then presents six taxonomies for them. The first taxonomy is based on the level of functionality of a system in a domain. The second taxonomy is based on primacy of functionality and the third one relies on essentialness of functionality of the system. The fourth taxonomy is concerned with supporting of functionality. The fifth taxonomy is based on the boundary of functionality and the sixth one is related to generalization/specialization relation. Then the use cases are evaluated in a case study in a control command police system. Several guidelines are recommended for developing use cases and their refinement, based on some
practical experience obtained from the evaluation.
1. Use case diagrams show functional requirements without specifying order, data or control flow. Straight lines connect actors to use cases.
2. Actor generalization and use case extension/inclusion are shown. Extension improves on a use case, inclusion completes tasks for another use case.
3. External systems that use the system under design are represented, without data flow. Their placement is not critical.
Use case diagrams describe interactions between actors and a system to accomplish goals. A use case diagram typically includes:
1) Actors that interact with the system from outside, such as users or other systems. Common actor types are primary actors whose goals are fulfilled by the system and supporting actors that provide services.
2) Use cases that represent functions or tasks performed by the system. They are connected to relevant actors and may have relationships like include and extend.
3) Relationships between use cases like include, which shows a use case incorporating another, and extend, where a use case optionally extends another.
Use case diagrams provide an overview of a system's functions and how outside actors interact with them at a
Banknote design management should invest in user needs. When cash is no longer an attractive payment instrument,
banknotes will disappear. User needs will lead to other design requirements as applied today. Furthermore, banknote
designers should focus first of all on the User Interface Functions, instead of spending their creativity to User
Experience Functions like connecting to a main image.
Operationalize deep learning models for fraud detection with Azure Machine Le...Francesca Lazzeri, PhD
Recent advancements in computing technologies along with the increasing popularity of ecommerce platforms have radically amplified the risk of online fraud for financial services companies and their customers. Failing to properly recognize and prevent fraud results in billions of dollars of loss per year for the financial industry. This trend has urged companies to look into many popular artificial intelligence (AI) techniques, including deep learning for fraud detection. Deep learning can uncover patterns in tremendously large datasets and independently learn new concepts from raw data without extensive manual feature engineering. For this reason, deep learning has shown superior performance in domains such as object recognition and image classification.
Although, neural networks have been used for fraud detection for decades, recent advancements in computing technologies along with large volumes of data available today have dramatically improved the effectiveness of these techniques. Using a sample dataset that contains transactions made by credit cards in September 2013 by European cardholders, Francesca Lazzeri and Jaya Mathew explain how to build, deploy, and operationalize a deep learning model to identify and prevent fraud, using Azure Machine Learning Workbench to show the main steps in the operationalization process (from data ingestion to consumption) and the Keras deep learning library with Microsoft Cognitive Toolkit CNTK as the backend.
Presents a more expansive view of "stakeholders" in systems design, specifically beyond purely human notions. Produced for use by the IEEE P7000 working group "Model Process for Addressing Ethical Concerns During System Design."
The document discusses use case modeling and provides information on key concepts:
- A use case describes interactions between a system and external users (actors) to achieve a goal. It specifies system behavior but not implementation.
- Key components of use case modeling include actors, use cases, relationships between use cases like inclusion and extension, and use case descriptions.
- Use cases capture functional requirements while use case descriptions elaborate different scenarios through structured text or pseudocode. Organizing use cases into packages supports generalization and specialization.
The document discusses techniques for dynamic analysis and modeling in object-oriented systems. It describes developing use case scenarios, system-level sequence diagrams, subsystem-level diagrams, three-tier sequence diagrams involving boundary, control and entity objects, and statechart diagrams for control objects. The goal is to transform requirements into an implementation through modeling object interactions and behavior.
The document discusses requirements definition and system modeling. It defines requirements as conditions or capabilities needed by stakeholders to solve problems or achieve objectives. Requirements should be defined at three levels - business, user, and product. Business requirements define problems to be solved or opportunities addressed. User requirements describe functionality from the user perspective. Product requirements specify functionality that must be built into the software. System modeling helps understand functionality and communicate with customers using models from different perspectives. Requirements definition and system modeling lay the foundation for software development.
The document discusses use case modeling and UML diagrams. It provides an overview of commonly used UML diagrams such as use case diagrams, activity diagrams, class diagrams, sequence diagrams, and collaboration diagrams. It then describes use cases, use case diagrams, and relationships between use cases including include, extend, and generalize relationships.
Welcome to my series of articles on Unified Modeling Language. This is "Session 2 – Use Case UML" of the series. I have covered Use Case Scenario, Use Case Narrative and Use Case Model in this session.
Please view my other documents where I have covered each UML diagram with examples
A use case describes interactions between an actor and a system to achieve a goal. It represents a discrete unit of functionality provided by the system. The key components of a use case include the actor, system boundary, and use cases within the boundary. An actor can be a person or external system. A use case should be written from the perspective of the actor and describe the measurable value or objective the actor wants to achieve through their interaction with the system. Use case diagrams are used during requirements gathering and analysis to identify the functional scope of the system and external factors that influence it from the viewpoint of users, not developers.
Use case modeling involves describing how users will interact with a system to achieve goals. A use case represents a dialog between a user and the system, specifying what information must pass between them without detailing the system's internal workings. Each use case should have a name that includes a verb describing the user's goal. Actors represent people or systems that interact with the system-to-be to accomplish responsibilities. Sequence diagrams visually depict the information exchanged between actors and the system in specific use case scenarios.
Financial Analysis of Berlin Brandenburg AirportTotal of 3000 woChereCheek752
This document provides a template and guidelines for writing a Software Requirements Specification (SRS) to document the requirements for a software project. The SRS template includes 10 sections: Introduction, Overall Description, Use Case Diagram and Descriptions, User Interfaces, Other Nonfunctional Requirements, Other Requirements, Data Flow Diagram, Functional Requirements, Sequence Diagram, and Class Diagram. The document explains the purpose and provides examples of the content expected in each section to clearly define the requirements, features, interfaces, and design of the software system.
The document discusses elements of an analysis model for software engineering requirements, including use case diagrams. It provides information on use cases, actors, relationships between use cases and actors, and how to describe use cases using user stories, diagrams, and textual descriptions. An example use case diagram is also included to illustrate these concepts.
This document provides an overview of engineering analysis and design (modelling and simulation) with a focus on systems and simulation. It defines a system as a collection of components organized for a common purpose. Simulation is defined as imitating the operation of a real-world process over time by generating artificial history. The key benefits of simulation are that it allows experimenting with models to study the effects of changes before implementing them in the real world and to help with system analysis, design, and prediction.
This chapter discusses identifying and modeling functional requirements through use cases and user stories. It describes two techniques for identifying use cases: the user goal technique which identifies user goals and tasks, and the event decomposition technique which identifies system responses to different event types. The chapter also covers modeling use cases with descriptions, diagrams, and relationships to define the system functions and actors.
Use case diagrams depict the functionality of a system from a user perspective by showing actors, use cases, and relationships between them. Actors represent roles that interact with the system, while use cases represent system functions. Relationships include association, extend, generalization, uses, and include. Each use case contains details like preconditions, postconditions, normal and alternative flows, and exceptions. Use cases are identified through actor-based and event-based methods by determining actor tasks and system responses to external events.
The document provides an overview of a 7-step process for building an information system. The 7 steps are: 1) Identify and list stakeholders, 2) Identify and list actors, 3) Identify and list use cases, 4) Identify and list scenarios, 5) Identify and list steps, 6) Identify and list classes/objects, and 7) Manage work products. It describes each step in the process, including defining stakeholders, actors, use cases, scenarios, and mapping analysis to design. The process emphasizes discovery, iteration, and developing a shared understanding between stakeholders.
A use case diagram visually presents interactions between a system and external users or systems. It uses common UML elements like actors, use cases, and relationships. Key elements include actors that represent user roles, use cases that define system functionality, and relationships that show how actors interact with use cases. A use case description provides additional text details for each interaction. Examples demonstrate use case diagrams for bank ATMs and a student-teacher information system.
The document contains sections on software engineering topics related to object-oriented analysis and design. It covers requirements analysis, use case modeling, domain modeling, system sequence diagrams, and operation contracts. Some key points include:
- Requirements are categorized using the FURPS+ model and artifacts include use cases, supplementary specifications, and a glossary.
- A use case describes interactions between an actor and the system to support a goal through scenarios. Common formats are brief, fully dressed, and structured text.
- A domain model shows concepts and relationships in the problem domain through objects and associations. System sequence diagrams illustrate scenarios through message flows.
- Operation contracts specify preconditions, postconditions, and references for
The document discusses the unified process and use case diagrams in software development. It introduces the unified process which is an iterative and evolutionary software development methodology consisting of inception, elaboration, construction, and transition phases. The document also covers use cases, actors, use case diagrams, and how use cases influence analysis, design, implementation, project management, and testing in object-oriented software development.
Information systems analysis and requirements analysis produces a requirements specification. This specification states the project goal and the related data storage, data movement
The document discusses use case diagrams and modeling. Use case diagrams capture system requirements and define interactions between actors and the system. Components include actors, represented by stick figures, and use cases, represented by ellipses. Use cases describe a unit of work and can include name, description, requirements, constraints, and scenarios. Relationships between use cases include include, extend, and inherit. Include references a lower-level use case. Extend adds additional sequences. Inherit replaces scenarios. Boundaries show actors outside and use cases inside the system. Steps should show actor goals, not interfaces.
The document discusses use case modeling and diagrams. It defines a use case as a sequence of actions a system performs that yields an observable result for an actor. Use case diagrams depict the interactions between actors and the services (use cases) provided by the system. They help identify the classes needed for the system and provide a starting point for requirements, analysis, design, testing, and documentation. The example models the use cases for a bank that offers savings, checking, fixed deposit accounts and ATM services.
The document discusses user experience (UX) and user interface (UI) design. It begins by defining UX and UI, noting that UX focuses on putting the user at the center and ensuring a system meets their needs, while UI relates to the layout and design of application controls. The document then discusses why UX/UI is important, providing examples of how poor design can negatively impact user adoption and satisfaction. It outlines principles of user-centered design and techniques for evaluating UX like interviewing and observing users. The rest of the document discusses methods for designing interfaces like paper prototyping and wireframing, as well as principles for good UI design such as consistency and providing feedback.
The document discusses the AWS Cloud Adoption Framework (CAF) and provides guidance for organizations undergoing a digital transformation. It describes the six perspectives of the CAF - business, people, governance, platform, security, and operations. For each perspective, it outlines the main areas of focus, potential changes needed in skills, processes and roles, and examples of common roles involved. It also provides a high-level overview of the stages of cloud adoption and seven best practices for a successful cloud transition.
This presentation is demonstration about database migration example by consuming such services in the cloud, introducing cloudEndure, and success stories.
This document discusses how companies are transforming digitally and adopting modern application architectures using containers on AWS. It covers:
1) The need for digital transformation and modern architectures to remain competitive.
2) How AWS customers are innovating using microservices architectures, serverless computing, and containers.
3) Best practices for developing and deploying containerized applications on AWS, including using Docker containers, AWS Fargate for serverless containers, and Amazon EKS for Kubernetes.
challenges and difficulties that you may think when you are trying to use cloud services which maybe used in many fields with also customers success stories in consuming such services.
The importance of security topic in the cloud and you should responsible of your data type in the cloud, covering AWS compilance and design, Detecting threats
The presentation is overview about the AWS digital transformation event, with various range of information about AWS services and customers success stories.
This document discusses email security and the Pretty Good Privacy (PGP) encryption software. It describes why email security is important given threats like loss of confidentiality and integrity. It then provides details on PGP, including how it uses public/private key encryption and digital signatures to encrypt messages and authenticate senders. PGP uses symmetric encryption of messages and asymmetric encryption of session keys, storing keys in a local ring. The document discusses PGP key management and its use of a web of trust model without a central authority.
This document discusses securing email and TCP connections using SSL. It explains that multiple layers of security are used to provide user-level security more easily. For email, it describes how confidentiality, sender authentication, message integrity, and receiver authentication are achieved through public/private key cryptography and digital signatures. It provides an example of using PGP to digitally sign an email. It then explains how SSL works to provide confidentiality, integrity, and server authentication for TCP connections by using a handshake process, key derivation, and encrypting data transfer with generated keys.
GameObjects are the most basic elements in Unity that can have various components attached to define their properties and behavior. A GameObject itself does not do anything without components. Components are added to GameObjects to make them characters, environments, effects etc. The transform component is essential as it defines the GameObject's position, rotation and scale in the scene. Parenting one GameObject to another makes the child object move and rotate with its parent. Scale also affects how GameObjects interact in the scene and with physics.
Unity 3D is a game engine that allows users to create 3D games. The main components of a Unity project include scenes stored in the project view, game objects organized in the hierarchy, and views like the scene view to build levels and the game view to test games. Key concepts include parenting game objects to link their transformations and using the transform tools to move, rotate, and scale objects in the scene view.
This document provides an overview of Unity, an integrated development environment for creating 3D video games. It can deploy games to multiple platforms like Windows, web, mobile. Unity has built-in assets, networking and AI capabilities. The document instructs on downloading and installing Unity, and provides examples of games like Angry Bots that have been created with Unity and deployed to platforms like Android.
Getting to know unity, special thanks to JUST and my friend Ruba Al-Saa'di and Dr. Natheer.
We are waiting for Patented a small request caused a technology revolution.
Get Success with the Latest UiPath UIPATH-ADPV1 Exam Dumps (V11.02) 2024yarusun
Are you worried about your preparation for the UiPath Power Platform Functional Consultant Certification Exam? You can come to DumpsBase to download the latest UiPath UIPATH-ADPV1 exam dumps (V11.02) to evaluate your preparation for the UIPATH-ADPV1 exam with the PDF format and testing engine software. The latest UiPath UIPATH-ADPV1 exam questions and answers go over every subject on the exam so you can easily understand them. You won't need to worry about passing the UIPATH-ADPV1 exam if you master all of these UiPath UIPATH-ADPV1 dumps (V11.02) of DumpsBase. #UIPATH-ADPV1 Dumps #UIPATH-ADPV1 #UIPATH-ADPV1 Exam Dumps
The Science of Learning: implications for modern teachingDerek Wenmoth
Keynote presentation to the Educational Leaders hui Kōkiritia Marautanga held in Auckland on 26 June 2024. Provides a high level overview of the history and development of the science of learning, and implications for the design of learning in our modern schools and classrooms.
Information and Communication Technology in EducationMJDuyan
(𝐓𝐋𝐄 𝟏𝟎𝟎) (𝐋𝐞𝐬𝐬𝐨𝐧 2)-𝐏𝐫𝐞𝐥𝐢𝐦𝐬
𝐄𝐱𝐩𝐥𝐚𝐢𝐧 𝐭𝐡𝐞 𝐈𝐂𝐓 𝐢𝐧 𝐞𝐝𝐮𝐜𝐚𝐭𝐢𝐨𝐧:
Students will be able to explain the role and impact of Information and Communication Technology (ICT) in education. They will understand how ICT tools, such as computers, the internet, and educational software, enhance learning and teaching processes. By exploring various ICT applications, students will recognize how these technologies facilitate access to information, improve communication, support collaboration, and enable personalized learning experiences.
𝐃𝐢𝐬𝐜𝐮𝐬𝐬 𝐭𝐡𝐞 𝐫𝐞𝐥𝐢𝐚𝐛𝐥𝐞 𝐬𝐨𝐮𝐫𝐜𝐞𝐬 𝐨𝐧 𝐭𝐡𝐞 𝐢𝐧𝐭𝐞𝐫𝐧𝐞𝐭:
-Students will be able to discuss what constitutes reliable sources on the internet. They will learn to identify key characteristics of trustworthy information, such as credibility, accuracy, and authority. By examining different types of online sources, students will develop skills to evaluate the reliability of websites and content, ensuring they can distinguish between reputable information and misinformation.
8+8+8 Rule Of Time Management For Better ProductivityRuchiRathor2
This is a great way to be more productive but a few things to
Keep in mind:
- The 8+8+8 rule offers a general guideline. You may need to adjust the schedule depending on your individual needs and commitments.
- Some days may require more work or less sleep, demanding flexibility in your approach.
- The key is to be mindful of your time allocation and strive for a healthy balance across the three categories.
Post init hook in the odoo 17 ERP ModuleCeline George
In Odoo, hooks are functions that are presented as a string in the __init__ file of a module. They are the functions that can execute before and after the existing code.
CapTechTalks Webinar Slides June 2024 Donovan Wright.pptxCapitolTechU
Slides from a Capitol Technology University webinar held June 20, 2024. The webinar featured Dr. Donovan Wright, presenting on the Department of Defense Digital Transformation.
Decolonizing Universal Design for LearningFrederic Fovet
UDL has gained in popularity over the last decade both in the K-12 and the post-secondary sectors. The usefulness of UDL to create inclusive learning experiences for the full array of diverse learners has been well documented in the literature, and there is now increasing scholarship examining the process of integrating UDL strategically across organisations. One concern, however, remains under-reported and under-researched. Much of the scholarship on UDL ironically remains while and Eurocentric. Even if UDL, as a discourse, considers the decolonization of the curriculum, it is abundantly clear that the research and advocacy related to UDL originates almost exclusively from the Global North and from a Euro-Caucasian authorship. It is argued that it is high time for the way UDL has been monopolized by Global North scholars and practitioners to be challenged. Voices discussing and framing UDL, from the Global South and Indigenous communities, must be amplified and showcased in order to rectify this glaring imbalance and contradiction.
This session represents an opportunity for the author to reflect on a volume he has just finished editing entitled Decolonizing UDL and to highlight and share insights into the key innovations, promising practices, and calls for change, originating from the Global South and Indigenous Communities, that have woven the canvas of this book. The session seeks to create a space for critical dialogue, for the challenging of existing power dynamics within the UDL scholarship, and for the emergence of transformative voices from underrepresented communities. The workshop will use the UDL principles scrupulously to engage participants in diverse ways (challenging single story approaches to the narrative that surrounds UDL implementation) , as well as offer multiple means of action and expression for them to gain ownership over the key themes and concerns of the session (by encouraging a broad range of interventions, contributions, and stances).
1. 1
Chapter 3
Use Case Modeling & Analysis
Object-Oriented Technology
From Diagram to Code with Visual Paradigm for UML
Curtis H.K. Tsang, Clarence S.W. Lau and Y.K.
Leung
McGraw-Hill Education (Asia), 2005
2. 2
References
Chapter 3, Object-Oriented Technology:
From diagram to code with Visual
Paradigm for UML
Chapter 16-17, The UML User Guide
3. 3
What You Will Learn
State the components of a use case model.
Describe how use case models help address
common requirements definition problems.
Apply a step-by-step approach to develop use
cases.
Document use cases.
Incorporate use case modeling into the
project life cycle.
4. 4
Requirements Elicitation
A requirement describes a condition or
capability to which a system must
conform.
Requirements are supposed to
represent “what” the system should do
as opposed to 'how' the system should
be built.
5. 5
Common Problems in Defining
Requirements
Numerous studies have shown that over half of
software development projects do not work.
The major reason cited is that they do not do what
the users actually want, suggesting that there is a
breakdown in the “requirements elicitation” process.
Traditionally, requirements stated in software
requirements specifications are simple declarative
statements written in a text-based natural-language
style (e.g. “When the user logs in, the system
displays a splash screen as shown in Figure X.”).
6. 6
Common Problems in Defining
Requirements (cont’d)
Developers always use typical scenarios provided in
the specifications to try to understand what the
requirements of a system mean and how a system
is supposed to behave.
Unfortunately, software requirements specifications
are rarely documented in an effective manner.
7. 7
Use Case Modeling for Requirements
Elicitation
A use case consists of a series of actions that a user
must initiate with the system to carry out some useful
work and to achieve his/her goal.
A use case is a sequence of transactions performed
by a system that produces a measurable result for
a particular actor.
A good use case must represent the point of view of
the people who will use or interact with the system.
A use case should be considered as a unit of
requirement definition or simply a user goal, such as
“deposit money”, or “check balance” in an automatic
teller machine (ATM) system.
A complete set of use cases = system requirements.
8. 8
Use Case Modeling Techniques
A use case diagram enables the system designer to
discover the requirements of the target system from
the user's perspective.
If the designer uses use case diagrams in the early
stage of system development, the target system is
more likely to meet the needs of the user.
From both the designer and user’s perspectives, the
system will also be easier to understand.
Furthermore, use case analysis is a very useful tool
for the designer to communicate with the client.
9. 9
Use Case Model
A use case model is a diagram or set of diagrams
that together with some additional documentation
show what the proposed software system is designed
to do. A use case diagram consists of three main
components:
actors,
use cases, and their communications, and
some additional documentation such as use case
descriptions for elaborating use cases and problem
statements that are initially used for identifying use cases.
In addition, a use case diagram may consist of a
system boundary.
11. 11
Actors
Actors are the external entities that
interact with the system.
An actor may be:
people;
computer hardware and devices; or
external systems.
12. 12
Actors (cont’d)
An actor represents a role that a user can
play, but not a specific user.
For example, John and Peter may be
consultants, but John may also be a project
manager in the company.
Thus, the same person may be an instance of
more than one actor, and conversely several
people can play the same role of an actor.
13. 13
Actors (cont’d)
Primary actors are those who use the system’s
main functions, deriving benefits from it directly.
Primary actors are completely outside the system and drive
the system requirements.
Primary actors use the system to achieve an observable
user goal.
Secondary actors play a supporting role to
facilitate the primary actors to achieve their goals.
Secondary actors often appear to be more inside the system
than outside.
Secondary actors are usually allocated many system
requirements that are not derived directly from the statement
of requirements. Hence, the designer can have more
freedom in specifying the roles of these actors.
14. 14
Generalization Actors
The fact that actors are classes means that actors can be
generalized.
Through the generalization process, we can identify the
similarities between different actors.
15. 15
Use Cases
A use case describes a sequence of actions a system
performs to yield an observable result or value to a
particular actor.
Naming convention = verb + noun or verb + noun phrase,
e.g. withdraw cash.
A good use case should:
describe a sequence of transactions performed by a system
that produces a measurable result (goal) for a particular actor;
describe the behavior expected of a system from a user's
perspective;
enable the system analyst to understand and model a system
from a high-level business viewpoint; and
represent the interfaces that a system makes visible to the
external entities and the interrelationships between the actors
and the system.
16. 16
Example - ATM
An automatic teller machine (ATM) system is
typically used by different types of users
(actors).
One type of user, the customer, operates the
ATM to perform transactions with his/her
accounts through a computerized banking
network.
The banking network consists of a central
computer connecting to all ATM machines and
bank computers owned by individual banks.
Each bank computer is used to process the
transaction requested by its customers.
17. 17
Example – ATM (cont’d)
actor
communication system boundary
use case
system name
18. 18
Example – Hotel
Information System
We will consider a simple hotel information system
for two types of customers:
Tour Group customers and Individual
customers.
Tour Group customers are those who have
made reservations through a tour operator in
advance while Individual customers make their
reservations directly with the hotel.
Both types of customers can book, cancel,
check-in and check-out of a room by phone or
via the Internet.
20. 20
Structuring Use Cases
with Relationships
In the process of developing a use case
model, we may discover that some use
cases share common behaviors.
There are also situations where some use
cases are very similar but they have some
additional behaviors.
For example, in Figure 3.6, Withdraw
Money and Deposit Money both require
the user to log on to the ATM system.
21. 21
Structuring Use Cases with
Relationships (cont’d)
Use Case: Withdraw Money
Flow of Events:
1. The user inserts an ATM card.
The system prompts the user to enter
a password.
2. The user enters the password. The
system validates the user password.
....
….
….
Use Case: Deposit Money
Flow of Events:
1. The user inserts an ATM card. The
system prompts the user to enter a
password.
2. The user enters the password. The
system validates the user password.
....
….
….
Common
Behavior
22. 22
Structuring Use Cases with
Relationships (cont’d)
Use Case: Withdraw Money
Flow of Events:
1. include (login)
....
….
….
Use Case: Deposit Money
Flow of Events:
1. include (login)
….
….
…..
Use Case: Login Account
Flow of Events:
1. The user inserts an ATM card. The system
prompts the user to enter a password.
2. The user enters the password. The system
validates the user password.
24. 24
The <<include>> Relationship
Include relationships are used when two or
more use cases share some common
portion in a flow of events.
This common portion is then grouped and
extracted to form an inclusion use case for
sharing among two or more use cases.
Most use cases in the ATM system
example, such as Withdraw Money,
Deposit Money or Check Balance, share
the inclusion use case Login Account.
26. 26
The <<extend>> Relationship
Extend relationships are used when two
use cases are similar, but one does a bit
more than the other.
For example, you may have a use case
that captures the typical case (the base
use case) and use extensions to describe
variations.
A base use case may therefore
conditionally invoke an alternative use
case.
29. 29
The <<extend>> Relationship
(cont’d)
Alternative flow of
events
Base use case flow
of events
Alternative flow does not return to the point at which it
is inserted. <<extend>> relationship is for modeling
alternative flow!
30. 30
The <<extend>> Relationship
(cont’d)
Exception flow of events
Base use case flow
of events
Exception flow may or may not return to a base use
case flow. <<extend>> relationship is not for modeling
exceptions.
31. 31
The Generalization
Relationship
A child use case can inherit the behaviors,
relationships and communication links of a parent
use case.
In other words, it is valid to put the child use case
at a place wherever a parent use case appears.
The relationship between the child use case and
the parent use case is the generalization
relationship.
For example, suppose the ATM system can be
used to pay bills. Pay Bill has two child use cases:
Pay Credit Card Bill and Pay Utility Bill (see Figure
3.10).
33. 33
Base Use Case versus
Abstract Use Case
Base use case – invoked directly by actor to
achieve an observable goal.
Abstract use case – invoked by other use cases
and is not a complete goal from user’s
perspective.
e.g. withdraw cash (concrete use case) vs login
(abstract use case)
34. 34
Documenting Use Cases
A use case is a description of what a system is
used for, and who uses it, without providing details
of how it performs its functions.
A use case description serves as an agreed
description between the user and the system
designer on the flow of events that would happen
when a use case is invoked.
A use case description is explained and
elaborated through scenarios (a set of sequences
of actions).
Each of these scenarios is simply an instance of
the use case.
36. 36
Use Case Template
Use case name Name of the use case
Use case ID ID of the use case
Super use case The name of the generalized use case to which this
use case belongs
Actor(s) The name of the actor(s) who participates in the use
case
Brief
description
A description showing how this use case adds value
to the organization, that is, what the purpose or role of
this use case is in enabling the actors to do their job
Preconditions The conditions that must be satisfied before this use
case can be invoked
Post-conditions The conditions that will be established as a result of
invoking this use case
37. 37
Use Case Template (cont’d)
Flow of events A step-by-step description of the interactions
between the actor(s) and the system, and the
functions that must be performed in the specified
sequence to achieve a user goal
Alternative flows
and exceptions
Major alternatives or exceptions that may occur in the
flow of events
Priority The development priority of this use case
Non-behavioral
requirements
The non-functional requirements of the system such
as hardware and software platform requirements,
performance, security, etc.
Assumptions All the assumptions made about the use case
Issues All outstanding issues regarding the use case
Source Reference materials relevant to the use case
38. 38
Prioritizing Use Cases
The use case model is not only useful for
requirements specification but also for
planning the work in different phases of the
system development life cycle.
Since the use case model should be
understandable by both the system
developer and the user, it is quite natural
to plan the development of the system by
scheduling the completion dates of the use
cases in the use case model.
39. 39
Prioritizing Use Cases (cont’d)
The following factors typically increase the
priority ranking of a use case:
Architectural significance of the use case;
Use of new and untested technologies;
Problems which require substantial research
effort;
Great improvement in efficiency (or revenue) of
the business process; and
Use cases that support major business
processes.
40. 40
The Use Case Modeling and
Analysis Process
Business Workflow Analysis
Problem Statement
ATM
Withdraw Money
Deposit Money
Check Balance
Customer
Use Case
Analysis
Withdraw Money
Prcess Excess
Limit
*
*
Use Model
Structuring Use Cases
Domain Analysis
Login Account
<<include>>
<<extend>>
Test Cases
Behavioral
Modeling
(See Next
Chapter)
Develop Use Case
Description
Textual
Analysis
Domain
Class Model
Use Case Description
Brief
Description
Flow of
Events
Instance
Scenario
(Sucessfully
Withdraws
$250.00)
Grouping Use Case
Into Packages
41. 41
Steps in Developing
Use Case Models
Developing an initial use case model
Developing the problem statement
Identifying the major actors and use cases
Creating an initial use case diagram
Describing briefly the use cases (with initial descriptions)
Identifying/refining candidate business (domain) classes using
textual analysis
Refining the use case model
Developing base use case descriptions
Iteratively elaborating on the base use case descriptions and
determining the extend, include and generalization
relationships
Developing instance scenarios
Prioritizing use cases
42. 42
Developing the
problem statement
The chief executive officer of a mail order company is interested in
computerizing the company’s business process in order to improve
operational efficiency. The major business activities of the company
can be briefly described as follows:
A customer registers to become a member by filling in the
membership form and mailing it to the company. A member who
has not been active (no transactions) for a period of one year will
be removed from the membership list and he/she needs to apply
for reinstatement of the lapsed membership.
A member should inform the company of any change in personal
details, such as home address, telephone numbers, etc.
A member can place an order by filling out a sales order form and
faxing it to the company or by phoning the Customer Service
Assistant with the order details.
The Customer Service Assistant checks the validity of membership
and then enters the sales order information into the system.
43. 43
Developing the problem
statement (cont’d)
The Order Processing Clerk checks the availability of the
ordered items and, if they are available, holds them for the
order. When all the ordered items are available, the Order
Processing Clerk will schedule their delivery.
The Inventory Control Clerk controls and maintains an
appropriate level of stock and is also responsible for
acquiring new items.
If there is a problem with an order, the member will phone
the Customer Service Assistant, who will then take
appropriate action to follow up the particular sales order.
Members may return defective goods within 30 days and get
their money back.
The system will record the name of the staff member who
handles the transaction for future follow up action.
44. 44
Identifying Major Actors
Customer Service Assistant
Order Processing Clerk
Inventory Control Clerk
Actor Specification:
Actor name: Order Processing Clerk
Description: The Order Processing Clerk is responsible for
processing sales orders, submitting reorder requests,
requesting necessary deposits from members and scheduling
the delivery of the goods to members.
45. 45
Guidelines for Identifying
Use Cases
The following questions may be useful in
collecting information from users:
What are the main tasks carried out by each actor?
What data are manipulated and processed by the
system?
What problems is the system going to solve?
What goals does an actor want to achieve using the
system?
What are the major problems with the current system
and how could the proposed system simplify the work of
the user?
47. 47
Identifying Use Cases
Check order status
Place order
Handle goods return
Update membership record
Archive membership
Register new member
Process order
Schedule delivery
Order goods
Receive goods
Deliver goods
49. 49
Describing the Use Case
Use case: Schedule Delivery
Use case ID: UC-300
Actor: Order Processing Clerk
Description: The Order Processing Clerk selects an order from the
list of filled sales orders. The system displays the sales order
details, and the member’s telephone number and address are
displayed. The Order Processing Clerk enters the delivery date and
time after talking with the member over the phone. The system
records the delivery date and time in a dispatch request to the
delivery team.
An Initial Use Case Description of the Schedule Delivery Use Case:
50. 50
Describing the Use Case
(cont’d)
An Initial Use Case Description of the Schedule Delivery
Use Case:
Use case: Check Order Status
Use case ID: UC-400
Actor: Customer Service Assistant
Description: The Customer Service Assistant enters the ID of
the member. The Customer Service Assistant selects a sales
order of the member. The system displays the status of the sales
order.
51. 51
Performing a Textual Analysis
To identify the objects and classes, perform a
textual analysis to extract all nouns and noun
phrases from the problem statement.
The following categories are more likely to
represent objects:
Tangible things (e.g. classroom, playground)
Conceptual things (e.g. course, module)
Events (e.g. test, examination, seminar)
Outside organizations (e.g. publisher, supplier)
Roles played (e.g. student, teacher, principal)
Other systems (e.g. admission system, grade reporting
system)
52. 52
Performing a Textual Analysis
(cont’d)
Use case: Schedule Delivery
Use case ID: UC-300
Actor: Order Processing Clerk
Description: The Order Processing Clerk selects an order from the
list of filled sales orders. The system displays the sales order
details, member’s telephone number and address. The Order
Processing Clerk enters the delivery date and time after talking
with the member over the phone. The system records the delivery
date and time in a dispatch request to the delivery team.
54. 54
Developing Base Use
Case Descriptions
Use case name Place Order
Use case ID UC-100
Super use case The name of the generalized use case to which this use case
belongs.
Actor(s) Customer Service Assistant
Brief
description
A Customer Service Assistant places an order and then
submits it for processing.
Preconditions The member must have registered with the system.
Post-conditions The Customer’s order will be directed to the order processing
department for processing.
55. 55
Developing Base Use Case
Descriptions (cont’d)
Flow of events 1.The Customer Service Assistant finds the member’s record
by entering the member’s ID or name. The system displays a
list of members which match the information entered by the
Customer Service Assistant.
2.The Customer Service Assistant selects the required
member record. The system displays the details of the
member.
3.The Customer Service Assistant selects “Place Order”. A
new order form and order ID are then generated and
displayed.
4.The Customer Service Assistant selects items from the
catalog and adds them to the order.
5.The Customer Service Assistant submits the order for
processing. The system records the order and forwards it to
the Order Processing Clerk.
56. 56
Developing Base Use Case
Descriptions (cont’d)
Alternative
flows and
exceptions
At any time the Customer Service Assistant can decide to
suspend the ordering process and come back to it later, or to
cancel the order.
Priority High
Non-behavioral
requirements
The system should be able to handle 20,000 new orders per
day.
Assumptions
Issues Is there any limit on the amount of an order?
Source User Interview Memo 21, 8/9/01
58. 58
Structuring Use Cases (cont’d)
Use case
name
Place Order
Use case ID UC -100
Super use case
Actor(s) Customer Service Assistant
Brief description A Customer Service Assistant places an order and then submits it for processing.
Preconditions The member must have registered with the system.
Post-conditions The Customer’s order will be directed to the order processing department for processing.
Flow of
events
1.Include (Find Member Record).
2.The Customer Service Assistant selects “Place Order”. A
new order form and order ID are then generated and
displayed.
3.The Customer Service Assistant selects items from the
catalog and adds them to the order.
4.The Customer Service Assistant submits the order for
processing. The system records the order and forwards it to
59. 59
Structuring Use Cases (cont’d)
Use case name Find Member Record
Use case ID UC-10
Brief
description
A member record is requested.
Post-conditions A membership record is returned.
Flow of events 1.The Customer Service Assistant finds the member record
by entering the member’s ID or name. The system displays
a list of members which match the information entered by
the Customer Service Assistant.
2.The Customer Service Assistant selects the required
member record. The system then displays the details of
that member.
Alternative
flows and
exceptions
No member record is found for the customer.
60. 60
Developing Instance Scenarios
A use case specifies all possible ways of using a
system functionality to achieve a user goal.
Sometimes, it is necessary to write some
examples (instance scenarios) to illustrate the
execution of a complex use case.
Instance scenarios are easier for the user to
understand, and they are very useful for clarifying
any ambiguity in the use case description.
The instance scenarios can also serve as test
cases for system testing.
61. 61
Developing Instance Scenarios
(cont’d)
Parent use case
name
Place Order
Parent use case
ID
UC-100
Instance name A sales order form is received but the membership number is
missing.
Instance ID UCIS-100-1
Environmental
conditions and
assumptions
The name (Peter Chan) and signature of the member are
available in the system.
Inputs A sales order form
62. 62
Developing Instance Scenarios
(cont’d)
Instance flow
description
The Customer Service Assistant enters “Peter Chan” to find
the member record. The system then displays a list of
members which match the member’s name.
The Customer Service Assistant repeatedly selects a
member record. The system displays the signature of the
member when a member record is selected.
The Customer Service Assistant selects “Place Order”. A
new order form and order ID are then generated and
displayed.
The Customer Service Assistant selects items from the
catalog and adds them to the order.
The Customer Service Assistant submits the order for
processing. The system records the order and forwards it to
the Order Processing Clerk.Outputs The sales order is placed.
63. 63
Prioritizing Use Cases
Priority Rank Use Case Reason
High Process Order Directly improves the efficiency of the business
process and affects the system architecture.
High Place Order Same as above
High Find Member
Record
Included as part of the Place Order use case.
Medium Order Goods Ordering goods is less often than processing order
but still is one of the major business processes.
Medium Deliver Goods Can improve the control of stock level.
Low Update Membership
Record
Small impact on the system architecture.
Low Register New
Member
Same as above.
64. 64
Tricks and Tips in Using
Case Analysis
Use Cases as a Communication Tool. It is important to make
sure that each use case emphasizes the functions of the system as
seen by the user and that they are understandable by both the user
and the system analyst.
Finding the Right Use Cases. Cockburn suggests that in order
to find the use cases for a given system, we must first examine the
goals of the system. Use cases provide an observable value to an
actor, and by focusing on how an actor can achieve the goals of a
system, we can identify the correct use cases quickly.
Correct Focus of Base Use Case. In identifying use cases, it
is easy to incorrectly focus on the process, rather than the system
goal. In the ATM example, one might have mistakenly chosen
“Login Account”, and “Select Transaction” as use cases.
65. 65
Tricks and Tips in Using Case
Analysis (cont’d)
A Good Use Case Should be Observable. In Figure 3.20,
the Verify Password use case is incorrect in that the customers
cannot “verify” password themselves! This use case describes an
internal task that the system needs to perform (hence unobservable
externally) and definitely should not be included in the use case
model.
66. 66
Tricks and Tips in Using Case
Analysis (cont’d)
Use Cases versus Process Charts
It is very easy to fall into the trap of thinking that use
cases are processes and that data flows in and out along
the association lines.
Similarly, the <<include>> and <<extend>> arrows
between use cases are often misread as directions of
either data flows or control flows.
67. 67
Tricks and Tips in Using Case
Analysis (cont’d)
Apply Textual Analysis in Different Contexts
When defining use cases in the use case descriptions,
use nouns and verbs consistently so that you can
identify objects using textual analysis and their
interactions at a later stage.
Textual analysis can also be applied to identify actors
and use cases from the problem statement.
To identify system actors, we should focus on questions
like: “Who are the system users?” “What are the external
entities which interact with the system?” and to identify
use cases, “What task(s) the system needs to perform to
fulfill the user goals?”
69. 69
Tricks and Tips in Using Case
Analysis (cont’d)
Use Bi-directional Communication Associations
70. 70
Tricks and Tips in Using Case
Analysis (cont’d)
Structure Use Case Models
The use case model can be simplified by factoring out
common behaviors that are required by multiple use
cases and then introducing the <<include>> stereotype.
If the base use case is complete and the behavior may
be optional, consider using the <<extend>> stereotype.
The use case structuring process also helps to save time
and efforts in analyzing the use cases.
However, it should be remembered that one should not
put too much effort into identifying the common
behaviors and optional behaviors since this may defeat
the advantage of saving time and effort.
71. 71
Tricks and Tips in Using Case
Analysis (cont’d)
Don’t Over Specify Use Cases with Too
Much Details
When designing a use case model, it is very
easy to get bogged down in excessive details.
Remember that even the flow of events inside
the use case description only serves to show
the interaction between the actor(s) and the
use case. In other words, only describe what
the system is supposed to do and not how the
system does it.
72. 72
Tricks and Tips in Using Case
Analysis (cont’d)
Fit Use Cases into System Architecture
Packages should be used where appropriate to make
the use case diagram more easily understood.
Use cases that form a natural grouping should be
organized into packages.