The document discusses use case diagrams in UML modeling. It defines key components of use case diagrams including use cases, actors, the system boundary, and relationships like include, extend, and generalization. It provides examples of how to construct a use case diagram based on system functions and user goals. Specific use case diagram examples shown include an online ordering system and a vending machine.
This lecture provide a review of requirement engineering process. The slides have been prepared after reading Ian Summerville and Roger Pressman work. This lecture is helpful to understand user, and user requirements.
Unified Modeling Language (UML) is a modeling language, used for design. Designed based on OMG Standard, Object this helps to express and design documents, software. This is particularly useful for OO design. Here is a brief tutorial that talks about UML usage.
The objective is to explain how a software design may be represented as a set of interacting objects that manage their own state and operations and to introduce various models that describe an object-oriented design.
This lecture provide a review of requirement engineering process. The slides have been prepared after reading Ian Summerville and Roger Pressman work. This lecture is helpful to understand user, and user requirements.
Unified Modeling Language (UML) is a modeling language, used for design. Designed based on OMG Standard, Object this helps to express and design documents, software. This is particularly useful for OO design. Here is a brief tutorial that talks about UML usage.
The objective is to explain how a software design may be represented as a set of interacting objects that manage their own state and operations and to introduce various models that describe an object-oriented design.
Design and Implementation in Software EngineeringKourosh Sajjadi
These slides were presented to the software engineering class held in IAUN. The main context is provided from the "Software Engineering" book authored by Sommerville.
Most of the icons used in the slides are provided in the flaticon.com website.
Thanks to our professor Habib Seifzadeh.
A cooperation with Mohammad Mostajeran.
The Constructive Cost Model (COCOMO) is an algorithmic software cost estimation model developed by Barry Boehm. The model uses a basic regression formula, with parameters that are derived from historical project data and current project characteristics.
Basic COCOMO compute software development effort (and cost) as a function of program size. Program size is expressed in estimated thousands of source lines of code (SLOC, KLOC).
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
Design and Implementation in Software EngineeringKourosh Sajjadi
These slides were presented to the software engineering class held in IAUN. The main context is provided from the "Software Engineering" book authored by Sommerville.
Most of the icons used in the slides are provided in the flaticon.com website.
Thanks to our professor Habib Seifzadeh.
A cooperation with Mohammad Mostajeran.
The Constructive Cost Model (COCOMO) is an algorithmic software cost estimation model developed by Barry Boehm. The model uses a basic regression formula, with parameters that are derived from historical project data and current project characteristics.
Basic COCOMO compute software development effort (and cost) as a function of program size. Program size is expressed in estimated thousands of source lines of code (SLOC, KLOC).
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
Materi yang ada pada slide ini berisi :
Pengenalan UML Sebagai Alat Bantu Pemodelan Pada Pembangunan Perangkat Lunak Menggunakan Pendekatan Analisis dan Desain Berorientasi Objek
Notasi, Semantik, dan Stereotype Pada UML
Komponen pada UML (Use Case View, Logical View, Physical View, dan Process View)
Pengenalan Use Case Diagram sebagai Use Case View Pada UML
Penjelasan Aktor, Generalisasi Aktor, dan Use Case
Penjelasan Use Case Scenario
Use Case Refinement (Relasi Include, Extends, dan Generalisasi Use Case)
----------------------------------------------------------------------
Keep in touch with me in :
Twitter : https://twitter.com/rizkiadam_1991
Email : rizkiadamunikom@gmail.com
IG : @rizkiadamkurniawan
Book Formatting: Quality Control Checks for DesignersConfidence Ago
This presentation was made to help designers who work in publishing houses or format books for printing ensure quality.
Quality control is vital to every industry. This is why every department in a company need create a method they use in ensuring quality. This, perhaps, will not only improve the quality of products and bring errors to the barest minimum, but take it to a near perfect finish.
It is beyond a moot point that a good book will somewhat be judged by its cover, but the content of the book remains king. No matter how beautiful the cover, if the quality of writing or presentation is off, that will be a reason for readers not to come back to the book or recommend it.
So, this presentation points designers to some important things that may be missed by an editor that they could eventually discover and call the attention of the editor.
Visual Style and Aesthetics: Basics of Visual Design
Visual Design for Enterprise Applications
Range of Visual Styles.
Mobile Interfaces:
Challenges and Opportunities of Mobile Design
Approach to Mobile Design
Patterns
2. Introduction:
What is UML?
UML , short for Unified Modeling Language, is a standardized modeling language consisting of
an integrated set of diagrams, developed to help system and software developers for
specifying, visualizing, constructing, and documenting the artifacts of software systems, as well
as for business modeling and other non-software systems.
Types of UML Diagrams –
*Use case Diagram
*Class Diagram
*Activity Diagram
*Sequence Diagram
*State Diagram
*Deployment Diagram
3. What is USE CASE
USE CASE:
* A use case is a pattern of behavior, the system exhibits.
* The use cases are sequence of actions that the user takes on a system to get
particular target.
* USE CASE is dialogue between an actor and the system.
4. A use case diagram is a graphical depiction of a user's possible interactions
with a system. A use case diagram shows various use cases and different
types of users the system has and will often be accompanied by other types
of diagrams
what is a use case diagram
5. * Representing the goals of system-user
interactions.
* Defining and organizing functional
requirements in a system.
* Specifying the context and requirements of a
system.
* Modeling the basic flow of events in a use
case.
Use case diagram objective
6. A use case diagram contains four main components here we gonna discuss about it
and others components also;
#Use Case
A use case represents a user goal that can be
achieved by accessing the system or software
application.
#Actor
Actors are used to represent the users of system, actors
can actually be anything that needs to exchange
information with the system.
7. #System
The scope of a system can be represented by a system (shape), or
sometimes known as a system boundary. The use cases of the
system are placed inside the system shape, while the actor who
interact with the system are put outside the system.
#Include
An include relationship specifies how the behavior for the
inclusion use case is inserted into the behavior defined for the
base use case.
8. #Extend
An extend relationship specifies how the behavior of the
extension use case can be inserted into the behavior
defined for the base use case.
#Generalization
A generalization relationship is used to
represent inheritance relationship between
model elements of same type.
9. ACTOR
* An actor is some one or something that must interact with the system
under development.
* Actors can be human or automated systems.
* Actors are not part of the system.
* UML notation for actor is stickman, shown below.
* Actors carry out use cases and a single actor may perform more than one
use cases.
* Actors are determined by observing the direct uses of the system.
10. Primary and Secondary Actors
• Primary Actor
– Acts on the system.
– Initiates an interaction with the system.
– Uses the system to fulfill his/her goal.
– Events Something we don’t have control over.
• Secondary Actor
– Is acted on/invoked/used by the system.
– Helps the system to fulfills its goal.
– Something the system uses to get its job done.
11. Linking Use Cases
• Association relationships.
• Generalization relationships.
• One element (child) "is based on" another element (parent).
• Include relationships.
• One use case (base) includes the functionality of another (inclusion case).
• Supports re-use of functionality.
• Extend relationships.
• One use case (extension) extends the behavior of another (base).
12. Generalization
Generalization is a relationship between a general use case and a more
specific use case that inherits and extends features to it.
use cases that are specialized versions of other use cases.
It is shown as a solid line with a hollow arrow point.
13. * The actor Order Registry Clerk can instantiate the
general use case Place Order.
* Place Order can also be specialized by the use
cases Phone Order or Internet Order.
Generalization Example
14. Include
• The base use case explicitly incorporates the behavior of another use case at a
location specified in the base.
• The included use case never stands alone. It only occurs as a part of some larger
base that includes it.
16. Extend
base <<extend>> extending
• The base use case implicitly incorporates the behavior of
another use case at certain points called extension points.
• The base use case may stand alone, but under certain
conditions its behavior may be extended by the behavior of
another use case.
18. How to create use case diagram
1. List main system functions (use cases) in a column:
– think of business events demanding system’s response
– users’ goals/needs to be accomplished via the system
– Create, Read, Update, Delete (CRUD) data tasks
– Naming use cases – user’s needs usually can be translated in data tasks
2. Draw ovals around the function labels
3. Draw system boundary
4. Draw actors and connect them with use cases (if more intuitive, this can
be done as step 2)
5. Specify include and extend relationships between use cases (yes, at the
end - not before, as this may pull you into process thinking, which does not
apply in UC diagramming).
19. Use-Case Diagrams: Example [1]
I. Begin with a Use Case!
A user placing an order with a sales company might follow these steps :
1. Browse catalog and select items.
2. Call sales representative.
3. Supply shipping information.
4. Supply payment information.
5. Receive conformation number from salesperson.
II. Then translate Use Case sequence into Diagram
20. Use-Case Diagrams: Example [2]
The salesperson could also be included
in this use case diagram because the
salesperson is also interacting with the
ordering system.
22. Use-Case Diagram Case Study [1]
Vending Machine
After client interview the following system scenarios were identified:
– A customer buys a product
– The supplier restocks the machine
– The supplier collects money from the machine
On the basis of these scenarios, the following three actors can be
identified:
Customer; Supplier; Collector (in this case Collector=Supplier)