This document provides information on object oriented analysis and use case modeling. It discusses identifying objects and their relationships, defining object operations and attributes, and modeling system functionality through use cases. Use cases describe interactions between actors and the system, including typical workflows, alternative scenarios, and pre- and post-conditions. Use case diagrams visually represent the relationships between actors and use cases.
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.
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 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 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.
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 refining a system definition through use case modeling. It explains how to detail use cases by structuring the basic and alternative flows of events. Guidelines are provided for writing use case reports and flows of events to clearly communicate system behavior to various audiences like users, designers, and testers.
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.
This document provides a business requirements document (BRD) template for a project with the placeholder name [Insert Project Name]. The summary includes:
- The BRD contains sections for version control, table of contents, project details, overview, stakeholders, assumptions and constraints, use cases, business requirements, and appendices.
- The use cases section includes templates for documenting use case narratives with fields for ID, name, description, preconditions, postconditions, normal course, and more.
- The business requirements section contains a template for documenting functional, reporting, security, service level, and support requirements.
In this lesson, you will develop a system using Use Cases.
You will:
Justify the need for a Use Case diagram
Identify and describe the essential elements in a UML Use Case diagram
Identifying the Actors in a System.
Identifying Use Cases in a System
Create a Use Case Diagram that shows the Use Cases in your system.
Recognize and document use case dependencies using UML notation for extends,includes, and generalization
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 requirements capture using UML use case diagrams. It describes how use case diagrams can be used to capture functional requirements by modeling actors, use cases, and relationships. Key aspects covered include identifying use cases and actors, documenting use case descriptions, modeling relationships between use cases and actors, and tips for effective use case modeling.
The document discusses use case analysis in software engineering. It defines what a use case is, including that it specifies system requirements and describes scenarios of how actors will use the system. It also defines actors, scenarios, different use case formats (brief, casual, fully dressed), and relationships between use cases like include and extend. The document then provides examples of identifying actors and writing use cases for a ridesharing and library management system.
The document discusses use case diagrams and their components. It defines key terms like actors, use cases, and relationships between use cases. It explains that use case diagrams model interactions between actors and a system, and capture the system's functional requirements. Diagrams show actors outside the system boundary and use cases inside it. Relationships like "include", "extend", and "generalization" define relationships between use cases. The document provides examples and guidelines for creating use case specifications that describe use case scenarios in detail.
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 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.
The document discusses various techniques for modeling software requirements including:
1) Entity-relationship diagrams (ERDs) which model data objects and their relationships to understand the data domain.
2) Use case modeling which describes scenarios of how external actors will use the system through use cases and diagrams.
3) Flow-oriented modeling using data flow diagrams (DFDs) which represent how data objects are transformed as they move through the system.
The document discusses various techniques for modeling software requirements including:
1) Entity-relationship diagrams (ERDs) which model data objects and their relationships to understand the data domain.
2) Use case modeling which describes scenarios of how external actors will use the system through use cases and diagrams.
3) Object-oriented modeling which defines classes, objects, attributes, methods, encapsulation, and inheritance.
4) Flow modeling using data flow diagrams (DFDs) which represent how data objects flow through the system as they are transformed.
Unit 3(advanced state modeling & interaction meodelling)Manoj Reddy
油
The document provides an overview of advanced state modeling and interaction modeling techniques in UML. It discusses nested state diagrams and concurrent state diagrams for controlling complexity in state diagrams. It also covers activity models, use case models, and sequence models for interaction modeling. The relationships between class models, state models, and interaction models are also briefly described.
The document discusses requirements elicitation for software development. It describes the typical activities in a software lifecycle including requirements elicitation, analysis, design, implementation, and testing. It discusses techniques for eliciting requirements such as questionnaires, interviews, document analysis, task analysis, and scenarios. Scenario-based design focuses on concrete examples rather than abstract ideas. Non-functional requirements like usability, performance, and security are also important to define. Eliciting requirements is challenging due to understanding large complex systems and communication between stakeholders.
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
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
This chapter discusses analysis and design modeling. It describes various analysis modeling approaches like structured analysis and object-oriented analysis. Structured analysis uses diagrams like data flow diagrams, entity-relationship diagrams, and state transition diagrams. Object-oriented analysis focuses on identifying classes, objects, attributes, and relationships. The chapter also covers data modeling concepts, flow-oriented modeling using data flow diagrams, scenario-based modeling with use cases, and developing behavioral models to represent system behavior. Analysis modeling creates representations of the system to understand requirements and lay the foundation for 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 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.
This document provides a business requirements document (BRD) template for a project with the placeholder name [Insert Project Name]. The summary includes:
- The BRD contains sections for version control, table of contents, project details, overview, stakeholders, assumptions and constraints, use cases, business requirements, and appendices.
- The use cases section includes templates for documenting use case narratives with fields for ID, name, description, preconditions, postconditions, normal course, and more.
- The business requirements section contains a template for documenting functional, reporting, security, service level, and support requirements.
In this lesson, you will develop a system using Use Cases.
You will:
Justify the need for a Use Case diagram
Identify and describe the essential elements in a UML Use Case diagram
Identifying the Actors in a System.
Identifying Use Cases in a System
Create a Use Case Diagram that shows the Use Cases in your system.
Recognize and document use case dependencies using UML notation for extends,includes, and generalization
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 requirements capture using UML use case diagrams. It describes how use case diagrams can be used to capture functional requirements by modeling actors, use cases, and relationships. Key aspects covered include identifying use cases and actors, documenting use case descriptions, modeling relationships between use cases and actors, and tips for effective use case modeling.
The document discusses use case analysis in software engineering. It defines what a use case is, including that it specifies system requirements and describes scenarios of how actors will use the system. It also defines actors, scenarios, different use case formats (brief, casual, fully dressed), and relationships between use cases like include and extend. The document then provides examples of identifying actors and writing use cases for a ridesharing and library management system.
The document discusses use case diagrams and their components. It defines key terms like actors, use cases, and relationships between use cases. It explains that use case diagrams model interactions between actors and a system, and capture the system's functional requirements. Diagrams show actors outside the system boundary and use cases inside it. Relationships like "include", "extend", and "generalization" define relationships between use cases. The document provides examples and guidelines for creating use case specifications that describe use case scenarios in detail.
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 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.
The document discusses various techniques for modeling software requirements including:
1) Entity-relationship diagrams (ERDs) which model data objects and their relationships to understand the data domain.
2) Use case modeling which describes scenarios of how external actors will use the system through use cases and diagrams.
3) Flow-oriented modeling using data flow diagrams (DFDs) which represent how data objects are transformed as they move through the system.
The document discusses various techniques for modeling software requirements including:
1) Entity-relationship diagrams (ERDs) which model data objects and their relationships to understand the data domain.
2) Use case modeling which describes scenarios of how external actors will use the system through use cases and diagrams.
3) Object-oriented modeling which defines classes, objects, attributes, methods, encapsulation, and inheritance.
4) Flow modeling using data flow diagrams (DFDs) which represent how data objects flow through the system as they are transformed.
Unit 3(advanced state modeling & interaction meodelling)Manoj Reddy
油
The document provides an overview of advanced state modeling and interaction modeling techniques in UML. It discusses nested state diagrams and concurrent state diagrams for controlling complexity in state diagrams. It also covers activity models, use case models, and sequence models for interaction modeling. The relationships between class models, state models, and interaction models are also briefly described.
The document discusses requirements elicitation for software development. It describes the typical activities in a software lifecycle including requirements elicitation, analysis, design, implementation, and testing. It discusses techniques for eliciting requirements such as questionnaires, interviews, document analysis, task analysis, and scenarios. Scenario-based design focuses on concrete examples rather than abstract ideas. Non-functional requirements like usability, performance, and security are also important to define. Eliciting requirements is challenging due to understanding large complex systems and communication between stakeholders.
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
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
This chapter discusses analysis and design modeling. It describes various analysis modeling approaches like structured analysis and object-oriented analysis. Structured analysis uses diagrams like data flow diagrams, entity-relationship diagrams, and state transition diagrams. Object-oriented analysis focuses on identifying classes, objects, attributes, and relationships. The chapter also covers data modeling concepts, flow-oriented modeling using data flow diagrams, scenario-based modeling with use cases, and developing behavioral models to represent system behavior. Analysis modeling creates representations of the system to understand requirements and lay the foundation for 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 the transport layer in networking. It describes two main transport protocols:
1) UDP is a connectionless protocol that provides best-effort delivery of datagrams across IP networks. It uses port numbers for demultiplexing but does not provide reliability.
2) TCP is a connection-oriented protocol that provides reliable, in-order delivery of streams of bytes between applications over unreliable IP networks. It uses a three-way handshake to establish connections and provides flow control and error checking.
This presentation summarizes display and storage devices, including CRT, LCD, and floppy disks. CRT works by using an electron gun to fire electrons at phosphor dots on the screen, while LCD uses liquid crystals to display images without emitting light. Key advantages of CRT include better image quality and color, while disadvantages are larger size, health risks from radiation, and high voltage. LCD has advantages of being thinner, using less power, and producing less heat and radiation, but has disadvantages like narrower viewing angles and lower contrast. Floppy disks were an early portable storage device but had limitations of small storage capacity and slow access times.
This presentation introduces database design using the entity-relationship model. It defines key concepts of the ER model including entities, attributes, relationships and cardinalities. It provides an example ER diagram and discusses extended features such as generalization, specialization and aggregation. The presentation was delivered to a professor by six students as part of their database management systems course.
The document provides information about stoichiometry, which is the calculation of quantities in chemical reactions. It discusses how balanced chemical equations can be used to calculate amounts of reactants needed and products formed. Mole ratios derived from balanced equations allow conversion between moles of reactants and products, as well as between moles and mass. Examples are given of stoichiometric calculations involving moles, mass, and limiting reagents. The concept of percent yield is introduced, which compares the actual and theoretical yields of a reaction.
Welcome to the March 2025 issue of WIPAC Monthly the magazine brought to you by the LinkedIn Group WIPAC Monthly.
In this month's edition, on top of the month's news from the water industry we cover subjects from the intelligent use of wastewater networks, the use of machine learning in water quality as well as how, we as an industry, need to develop the skills base in developing areas such as Machine Learning and Artificial Intelligence.
Enjoy the latest edition
How to Build a Maze Solving Robot Using ArduinoCircuitDigest
油
Learn how to make an Arduino-powered robot that can navigate mazes on its own using IR sensors and "Hand on the wall" algorithm.
This step-by-step guide will show you how to build your own maze-solving robot using Arduino UNO, three IR sensors, and basic components that you can easily find in your local electronics shop.
Air pollution is contamination of the indoor or outdoor environment by any ch...dhanashree78
油
Air pollution is contamination of the indoor or outdoor environment by any chemical, physical or biological agent that modifies the natural characteristics of the atmosphere.
Household combustion devices, motor vehicles, industrial facilities and forest fires are common sources of air pollution. Pollutants of major public health concern include particulate matter, carbon monoxide, ozone, nitrogen dioxide and sulfur dioxide. Outdoor and indoor air pollution cause respiratory and other diseases and are important sources of morbidity and mortality.
WHO data show that almost all of the global population (99%) breathe air that exceeds WHO guideline limits and contains high levels of pollutants, with low- and middle-income countries suffering from the highest exposures.
Air quality is closely linked to the earths climate and ecosystems globally. Many of the drivers of air pollution (i.e. combustion of fossil fuels) are also sources of greenhouse gas emissions. Policies to reduce air pollution, therefore, offer a win-win strategy for both climate and health, lowering the burden of disease attributable to air pollution, as well as contributing to the near- and long-term mitigation of climate change.
Best KNow Hydrogen Fuel Production in the World The cost in USD kwh for H2Daniel Donatelli
油
The cost in USD/kwh for H2
Daniel Donatelli
Secure Supplies Group
Index
Introduction - Page 3
The Need for Hydrogen Fueling - Page 5
Pure H2 Fueling Technology - Page 7
Blend Gas Fueling: A Transition Strategy - Page 10
Performance Metrics: H2 vs. Fossil Fuels - Page 12
Cost Analysis and Economic Viability - Page 15
Innovations Driving Leadership - Page 18
Laminar Flame Speed Adjustment
Heat Management Systems
The Donatelli Cycle
Non-Carnot Cycle Applications
Case Studies and Real-World Applications - Page 22
Conclusion: Secure Supplies Leadership in Hydrogen Fueling - Page 27
Indian Soil Classification System in Geotechnical EngineeringRajani Vyawahare
油
This PowerPoint presentation provides a comprehensive overview of the Indian Soil Classification System, widely used in geotechnical engineering for identifying and categorizing soils based on their properties. It covers essential aspects such as particle size distribution, sieve analysis, and Atterberg consistency limits, which play a crucial role in determining soil behavior for construction and foundation design. The presentation explains the classification of soil based on particle size, including gravel, sand, silt, and clay, and details the sieve analysis experiment used to determine grain size distribution. Additionally, it explores the Atterberg consistency limits, such as the liquid limit, plastic limit, and shrinkage limit, along with a plasticity chart to assess soil plasticity and its impact on engineering applications. Furthermore, it discusses the Indian Standard Soil Classification (IS 1498:1970) and its significance in construction, along with a comparison to the Unified Soil Classification System (USCS). With detailed explanations, graphs, charts, and practical applications, this presentation serves as a valuable resource for students, civil engineers, and researchers in the field of geotechnical engineering.
Optimization of Cumulative Energy, Exergy Consumption and Environmental Life ...J. Agricultural Machinery
油
Optimal use of resources, including energy, is one of the most important principles in modern and sustainable agricultural systems. Exergy analysis and life cycle assessment were used to study the efficient use of inputs, energy consumption reduction, and various environmental effects in the corn production system in Lorestan province, Iran. The required data were collected from farmers in Lorestan province using random sampling. The Cobb-Douglas equation and data envelopment analysis were utilized for modeling and optimizing cumulative energy and exergy consumption (CEnC and CExC) and devising strategies to mitigate the environmental impacts of corn production. The Cobb-Douglas equation results revealed that electricity, diesel fuel, and N-fertilizer were the major contributors to CExC in the corn production system. According to the Data Envelopment Analysis (DEA) results, the average efficiency of all farms in terms of CExC was 94.7% in the CCR model and 97.8% in the BCC model. Furthermore, the results indicated that there was excessive consumption of inputs, particularly potassium and phosphate fertilizers. By adopting more suitable methods based on DEA of efficient farmers, it was possible to save 6.47, 10.42, 7.40, 13.32, 31.29, 3.25, and 6.78% in the exergy consumption of diesel fuel, electricity, machinery, chemical fertilizers, biocides, seeds, and irrigation, respectively.
Were excited to share our product profile, showcasing our expertise in Industrial Valves, Instrumentation, and Hydraulic & Pneumatic Solutions.
We also supply API-approved valves from globally trusted brands, ensuring top-notch quality and internationally certified solutions. Lets explore valuable business opportunities together!
We specialize in:
Industrial Valves (Gate, Globe, Ball, Butterfly, Check)
Instrumentation (Pressure Gauges, Transmitters, Flow Meters)
Pneumatic Products (Cylinders, Solenoid Valves, Fittings)
As authorized partners of trusted global brands, we deliver high-quality solutions tailored to meet your industrial needs with seamless support.
2. 1. Modeling the functions of the system.
2. Finding and identifying the business objects.
3. Organizing the objects and identifying their
relationships.
3. Identifying objects:
Using concepts, CRC cards, stereotypes, etc.
Organising the objects:
classifying the objects identified, so similar objects can later be defined in
the same class.
Identifying relationships between objects:
this helps to determine inputs and outputs of an object.
Defining operations of the objects:
the way of processing data within an object.
Defining objects internally:
information held within the objects.
4. What are the two main goals of OO analysis?
1) Understand the customers requirements
2) Describe problem domain as a set of classes and relationships
What techniques have we studied for the 1st goal?
Develop a requirements specification
Describe scenarios of use in users language as use cases
What techniques have we studied for the 2nd goal?
CRC cards discover classes and run simulations
UML class diagrams represent classes & relationships
Sequence diagrams model dynamic behavior of a system
5. System analysis use case a use case that documents the interaction
between the system user and the system. It is highly detailed in describing
what is required but is free of most implementation details and constraints.
1. Identify, define, and document new actors.
2. Identify, define, and document new use cases.
3. Identify any reuse possibilities.
4. Refine the use-case model diagram (if necessary).
5. Document system analysis use-case narratives.
6. Use Case Diagrams describe the functionality of a system and
users of the system.
Describe the functional behavior of the system as seen by the
user.
These diagrams contain the following elements:
Actors, which represent users of a system, including human
users and other systems.
Use Cases, which represent functionality or services provided
by a system to users.
7. To draw an use case diagram we should have the following items
identified. Functionalities to be represented as an use case
Actors Relationships among the use cases and actors.
Use case diagrams are considered for high level requirement
analysis of a system. So when the requirements of a system
are analyzed the functionalities are captured in use cases.
8. Use case diagrams are drawn to capture the functional requirements
of a system. So after identifying the above items we have to follow
the following guidelines to draw an efficient use case diagram.
The name of a use case is very important. So the name should
be chosen in such a way so that it can identify the functionalities
performed.
Give a suitable name for actors. Show relationships and
dependencies clearly in the diagram.
Do not try to include all types of relationships.
Because the main purpose of the diagram is to identify
requirements.
Use note when ever required to clarify some important
points.
9. Used during requirements
elicitation to represent external
behavior
Actors represent roles, that is,
a type of user of the system
Use cases represent a
sequence of interaction for a
type of functionality
The use case model is the set
of all use cases. It is a
complete description of the
functionality of the system
and its environment
Passenger
PurchaseTicket
10. An actor models an external
entity which communicates
with the system:
User
External system
Physical environment
An actor has a unique name
and an optional description.
Examples:
Passenger: A person in the train
GPS satellite: Provides the
system with GPS coordinates
Passenger
11. A use case represents a class of
functionality provided by the system
as an event flow.
A use case consists of:
Unique name
Participating actors
Entry conditions
Flow of events
Exit conditions
Special requirements
PurchaseTicke
t
13. Example: High Level Use Case Diagram
Manage Resources
Manage Projects
System Admin
Resource Manager
Project Manager
System Administrator
14. Example: Managing Resources Use Case Diagram
Add Skill
Remove
Skill
Update
Skill
Find Skill
Add
Resource
Remove
Resource
Update
Resource
Find
Resource
Unassign
Skill from
Resource
Assign Skill
from
Resource
Resource Manager
15. The following is a sample use case diagram representing the order
management system. So if we look into the diagram then we will find
three use cases (Order, SpecialOrder and NormalOrder) and one actor
which is customer.
The SpecialOrder and NormalOrder use cases are extended from Order use
case. So they have extends relationship.
Example: Order management system
16. Dependences
Include Dependencies
Extend Dependencies
An include dependency from one
use case (called the base use
case) to another use case (called
the inclusion use case) indicates
that the base use case will include
or call the inclusion use case. A
use case may include multiple use
cases, and it may be included in
multiple use cases.
An extend dependency from one use
case (called the extension use case)
to another use case (called the base
use case) indicates that the extension
use case will extend (or be inserted
into) and augment the base use case.
A use case may extend multiple use
cases, and a use case may be
extended by multiple use cases.
A
B
A
B
17. Generalizations
Actors may be similar in how they use a system; for example, project
managers, resource managers, and system administrators may log in
and out of our project management system.
Use cases may be similar in the functionality provided to users; for
example, a project manager may publish a project's status in two
ways: by generating a report to a printer or by generating a web site
on a project web server.
18. Redraw the given use case diagram after applying:
generalization between actors
generalization between use cases;
include relationship between use cases.
Example
19. Query for Items
Rent Items
Pay Fines
Pay Fines Cash Pay Fines
Check
Open Folder
Open Folder by
typing name
Open Folder by
browsing
Manage Members
Manage Users Log In
Customer
Clerk
Administrator
Manager
include
include
include
20. Use case text provides the detailed description of a particular use case
Use Case ID: Give each use case a unique integer sequence number identifier.
Use Case Name: Start with a verb.
Created By: Last Updated By:
Date Created: Date Last Updated:
Actors: Calls on the system to deliver its services.
Description: "user-goal" or "sub-function"
Stakeholders and Interests: Who cares about this use case, and what do they want?
Trigger: Identify the event that initiates the use case.
Pre-conditions: What must be true on start, and worth telling the reader?
Post-conditions: Describe the state of the system at the conclusion of the use case
execution.
Normal Flow: A typical, unconditional happy path scenario of success.
Alternative Flows
(Extensions):
Alternative scenarios of success or failure.
Priority:
Indicate the relative priority of implementing the functionality
required to allow this use case to be executed.
Technology and Data
Variations List
Varying I/O methods and data formats.
Special Requirements: Related non-functional requirements.
Notes and Issues: Such as open issues.
Use Case Description
21. Use Case Identification
Use Case ID
Give each use case a unique integer sequence number identifier.
Use Case Name
State a concise, results-oriented name for the use case. These reflect the tasks the user needs to be
able to accomplish using the system. Include an action verb and a noun.
Use Case History
Created By
Date Created
Last Updated By
Date Last Updated
Actors
An actor is a person or other entity external to the software system being specified who interacts with
the system and performs use cases to accomplish tasks. Name the actor that will be initiating this use
case and any other actors who will participate in completing the use case.
Description
Provide a brief description of the reason for and outcome of this use case.
Stakeholders and Interests
Who cares about this use case, and what do they want?
Trigger
Identify the event that initiates the use case. This could be an external business event or system event
that causes the use case to begin, or it could be the first step in the normal flow.
Use Case Description
22. Use Case Definition
Pre-conditions
List any activities that must take place, or any conditions that must be true, before the use case can be
started. Number each precondition. Examples:
Users identity has been authenticated.
Users computer has sufficient free memory available to launch task.
Post-conditions
Describe the state of the system at the conclusion of the use case execution. Number each post-condition.
Examples:
Price of item in database has been updated with new value.
Normal (basic) Flow of events Happy path - Successful path Main Success Scenario
Provide a detailed description of the user actions and system responses that will take place during
execution of the use case under normal, expected conditions. This dialog sequence will ultimately lead to
accomplishing the goal stated in the use case name and description.
Alternative Flows (Extensions): Alternate scenarios of success or failure
Document other, legitimate usage scenarios that can take place within this use case separately in this
section. State the alternative flow, and describe any differences in the sequence of steps that take place.
Number each alternative flow in the form X.Y, where X is the Use Case ID and Y is a sequence number
for the alternative flow. For example, 5.3 would indicate the third alternative flow for use case number 5.
Use Case Description
23. Priority
Indicate the relative priority of implementing the functionality required to allow this use case to be
executed. The priority scheme used must be the same as that used in the software requirements
specification.
Technology and Data Variations List
Varying I/O methods and data formats.
Special Requirements
Identify any additional requirements, such as nonfunctional requirements, for the use case that
may need to be addressed during design or implementation. These may include performance
requirements or other quality attributes.
Notes and Issues
List any additional comments about this use case or any remaining open issues or TBDs (To Be
Determineds) that must be resolved. Identify who will resolve each issue, the due date, and what
the resolution ultimately is.
Use Case
Description
24. Use case text provides the detailed description
of a particular use case
Use case diagram provides an overview of
interactions between actors and use cases
25. The ClubRiyadh Sport has decided to implement an electronic card system for its subscriber, so that
subscribers can use their K-cards to access secure areas, and also as a debit card, linked to an account
into which subscribers can deposit money to be used to pay club fees. For the initial release of the
system, this will be limited to a few club usages: equipment rental at the sports centre, beverage fees,
and library fees at club libraries. The system will keep a usage record for each K-card.
Identify use cases by providing the actors, use case names. Draw the use case diagram.
27. I am the manager of a theatre.
I want to create an automated movie ticket machine.
You are analysts who need to describe
what the customer wants as a set of use cases
Simplifying assumptions:
One movie showing at a time
Movie time is same every day, only one time, same price
Only manager can change/add movie
Customer can only buy tickets
Who or what are the actors?
What are the use cases (goals of actors)?
Use case diagram for Movie Ticket Machine
28. Use case diagram for Movie Ticket Machine
# of tickets
Set title
Buy tickets
Give change
Set price
Customer
Manager
Set seats
Movie Ticket Machine
29. Use case: Set title
Actors: Manager, Machine
1. Manager requests a change of movie title
2. Machine asks manager for new movie title
3. Manager enters movie title
Use case: Set price
Actors: Manager, Machine
1. Manager requests a change of ticket price
2. Machine asks manager for new price for movie title
3. Manager enters ticket price
Alternatives: Invalid price
If manager enters price below SR5 or greater than
SR50
3a. Machine asks manager to reenter price
Use case: Set seats
Actors: Manager, Machine
1. Manager requests a change in number
of seats
2. Machine asks manager for number of
seats in theatre
3. Manager enters number of seats
Alternatives: Invalid number of seats
If manager enters number less than 20 or
greater than 999
3a. Machine asks manager to reenter
number of seats
Identification of Use Cases
30. Use case: # of tickets
Actors: Customer, Machine
1. Customer enters number of tickets
2. Machine displays total balance due
Alternative: Customer wants zero tickets
At step 1, customer enters zero tickets
1a. Display thank you message
1b. Set balance to $0.0
Use case: Return change to customer
Actors: Customer, Machine
1. Customer requests change
2. Machine dispenses money
3. Machine updates customer balance
Use case: Buy tickets
Actors: Customer, Machine
1. Customer requests tickets
2. Machine tells customer to put
balance due in money slot
3. Customer enters money in money slot
4. Machine updates customer balance
5. Customer requests tickets
6. Machine prints tickets
7. Machine updates number of seats
Alternative: Insufficient seats
At step 1, if number of tickets requested
is less than available seats,
1a. Display message and end use case
Alternative: Insufficient funds
At step 5, if money entered < total cost,
5a. Display insufficient amount entered
5b. Go to step 3
Identification of Use Cases
31. What is a Domain Model?
Illustrates meaningful conceptual classes in problem domain
Represents real-world concepts, not software components
A diagram (or set of diagrams) which represents real world
domain objects
conceptual classes
Not a set of diagrams describing software classes, or software
objects with responsibilities
32. to understand what concepts need to be modelled by
our system, and how those concepts relate
a springboard for designing software objects
33. conceptual classes
associations between conceptual classes
attributes of conceptual classes
34. A useful strategy for building a domain model is to start with:
the boundary concepts that interact directly with the actors
and then identify the internal concepts
Building the Domain Model
35. Identify Candidate Conceptual classes
Draw them in a Domain Model
Add associations necessary to record the relationships that
must be retained
Add attributes necessary for information to be preserved
38. Use a category list
Finding concepts using the
concept category list :
Physical objects: register,
airplane, blood pressure
monitor
Places: airport, hospital
Catalogs: Product Catalog
Transactions: Sale,
Payment, reservation
39. Noun phrases may also be attributes or parameters rather than classes:
If it stores state information or it has multiple behaviors, then its a class
If its just a number or a string, then its probably an attribute
Finding concepts using Noun Phrase identification in the textual description of the
domain :
44. sometimes we need to separate out the description
of a concept from the concept itself, so that even if
no instances of the concept exist at a given point in
time, its description will still be present in the
system.
doing this can reduce unnecessary redundancy in
recording information when we move into design
and build.
47. Professor
name
empID
create( )
save( )
delete( )
change( )
Class Name
Attributes
Operations
A class is comprised of three sections
The first section contains the class name
The second section shows the structure (attributes)
The third section shows the behavior (operations)
48. Object
Class
Attribute
Operation
Interface (Polymorphism)
Relationships
49. Object
Class
Attribute
Operation
Interface (Polymorphism)
Relationships
50. Object
Class
Attribute
Operation
Interface (Polymorphism)
Relationships
56. Student Schedule
Whole
Aggregation
Part
A special form of association that models a whole-
part relationship between an aggregate (the whole)
and its parts
Composition
58. Multiplicity defines how many objects
participate in a relationships
The number of instances of one class related to
ONE instance of the other class
Specified for each end of the association
Associations and aggregations are bi-
directional by default, but it is often desirable
to restrict navigation to one direction
If navigation is restricted, an arrowhead is added to
indicate the direction of the navigation
60. Multiplicity the
minimum and
maximum number of
occurrences of one
object/class for a
single occurrence of
the related object/class.
63. A relationship among classes where one class
shares the structure and/or behavior of one or
more classes
Defines a hierarchy of abstractions in which a
subclass inherits from one or more superclasses
Single inheritance
Multiple inheritance
Generalization is an is-a-kind of relationship
65. Airplane Helicopter Wolf Horse
FlyingThing Animal
Bird
multiple
inheritance
Use multiple inheritance only when needed, and
always with caution !
A class can inherit from several other classes
66. Inheritance leverages the similarities among classes
A subclass inherits its parents attributes,
operations, and relationships
A subclass may:
Add additional attributes, operations, relationships
Redefine inherited operations (use caution!)
Common attributes, operations, and/or
relationships are shown at the highest applicable
level in the hierarchy
67. we should model the important relationships
between conceptual classes
not every relationship, that would create clutter
and confusion
not too few, we want a useful model
for each association, provide:
a short yet meaningful text label
the multiplicity
69. Consider the world of libraries. A library has books, videos, and CDs that
it loans to its users. All library material has a id# and a title. In addition,
books have one or more authors, videos have one producer and one or
more actors, while CDs have one or more entertainers. The library
maintains one or more copies of each library item (book, video or CD).
Copies of all library material can be loaned to users. Reference-only
material is loaned for 2hrs and cant be removed from the library. Other
material can be loaned for 2 weeks. For every loan, the library records
the user, the loan date and time, and the return date and time. For
users, the library maintains their name, address and phone number.
Define the two main actors.
Identify use cases by providing the actors, use case names. Draw the us
e case diagram.
Create the conceptual class diagram.
Example: Library System
70. Draw a UML Class Diagram representing the following elements from
the problem domain for digital music players: An artist is either a band
or a musician, where a band consists of two or more musicians. Each
song has an artist who wrote it, and an artist who performed it, and a
title. Therefore, each song is performed by exactly one artist, and
written by exactly one artist. An album is composed of a number of
tracks, each of which contains exactly one song. A song can be used in
any number of tracks, because it could appear on more than one album
(or even more than once on the same album!). A track has bitrate and
duration. Because the order of the tracks on an album is important, the
system will need to know, for any given track, what the next track is,
and what the previous track is.
Draw a class diagram for this information, and be sure to label all
the associations (relationships) with appropriate multiplicities.
71. Applying UML & Patterns (Larman 2007),
Chapters 6, 9.
Object-Oriented Systems Analysis and Design
(Bennett et al, Third Edition, 2006), Chapter
6, 7.