Quiz 4

Extends Use Case:

a secondary use case describing an additional functionality that is only occasionally needed; e.g., contingent on something happening within the use case

Criteria to consider in an alternatives matrix:

business requirements, functional requirements, feasibility requirements, risks, and stakeholder objectives.

How to identify actors for a use case diagram:

who provides inputs or receives outputs from system

Criteria for a good use case description:

1) are all exception conditions documented and all alternative flows documented? 2) is it clear which actors benefit from the use case; 3) is action sequence written in System-Response mode; 4) are there at least 3-5 steps in the action sequence starting with primary actor initiating execution of use case by sending a request to the system, system ensuring that the request & data is valid, system processing the request including any changes to internal state of system and data, and system sending primary actor result of the processing.

Steps in creating a use case diagram:

1) draw box and place primary use cases in box; 2) place primary and secondary actors outside the box; 3) decide if generalization actor needed; 4) draw associations between actor to primary use cases; 5) add secondary use cases and draw relationships; 6) minimize line crosses

Criteria for well-developed primary use cases:

1) each use case represents 1 and only 1 role that a user has with the system (e.g., does not both deposit and take out money) 2) each primary use case is independent of all other primary use cases; 3) each primary use case provides something of value to the actor; 4) each primary use case interacts with an actor; 5) each primary use case is labeled as a verb/noun

Steps in identifying major use cases:

1) review to-be process to identify primary actors and their goals and review user stories from Agile 2) identify different interactions that the actor will have with system to achieve goals to create initial list of primary use cases; 3) determine if there are secondary actors that the use case relies on; 4) determine if any of the primary use cases need to be split into secondary use cases; 5) stop creating use cases at 9

Includes Use Case:

A secondary use case that contains common functions that are used by more than one use case; identifies reuse potential

Connection between User Stories in Agile and use cases in OOAD:

A use case can be the functionality specified in the user story, and the actor is the role specified in the story.

Internal actor

Actor WITHIN the system, e.g., the system could not function without the actor; does not receive value from the system and is so integral to the system that it cannot be modeled outside the system. Example: receptionist for an appointment system.

OOAD: Object-oriented system analysis and design.

Allows breaking a complex system into small parts called modules (like objects and classes) - which are then pieced together into packages which are reusable. So you can create a module called: "foreign exchange" which can be reused in every bank. "Web Services" uses modules, based on OOAD. Basis for OOAD is "use-case driven" (i.e., each major functionality is described in a use case description). Systems created using OOAD rest on the following principles: a) classes/objects are encapsulated to have both: attributes (descrption) and operations (e.g., behaviors such as a Patient class can make appointment, calculate last visit, change status, provide medical history, create) so they can run themselves; b) methods/messages calls for the execution of the operations of the object (e.g, create a new object: aPatient); c) information hiding meaning that it's the messages in and out of the class that matter not how the class performs - sometimes referred to as Wrappers; d) Inheritance of attributes and operations from superclasses to subclasses; e) polymorphism: the same message (e.g., drawyourself) can mean different operations for different classes (e.g., aSquare, aCircle, aTriangle), f) dynamic binding: objects are not typed until run-time when it is called by a message. OOAD languages include: Python, Ruby, Scala, Smalltalk, Eiffel, Emerald, JADE, Self. Some languages have both OO and procedural elements: Java, C++, C#, Delphi/Object Pascal, VB.NET. Languages that are historically procedural languages, but have been extended with some OO features include: PHP, Perl, Visual Basic (derived from BASIC), MATLAB, COBOL 2002, Fortran 2003, ABAP, Ada 95, Pascal (the languages list is from from Wikipedia)

Specialized actor

An actor who may at times interact with the system in a way that is somewhat different (more specialized) from the general role. Example; new patient is a specialized actor of the general type of patient role since the new patient interacts to indicate insurance for the first time.

Primary Actor

An external stakeholder that calls on the system to deliver one of its services. It has a goal to be satisfied by the system

Use Case

Documents the interactions between the system and actors to achieve the goal of the primary actor; it is depicted by an oval in the UML. It is a major process that the system performs and that benefits an actor or actors in some way; it is labeled using a descriptive verb-noun phrase; represents a major functionality of the system

Supporting or Secondary actor

External stakeholder that provides a service to the system (e.g., high-speed printer, credit reporting system); they provide assistance to the system to achieve the primary actor's goal.

SVDPI:

Sentences used in the flow of events of a use case description consisting of subject, verb , direct object, preposition, indirect object (exs: The borrower (S), brings (V), books (D), to (P) librarian (I) OR Customer (S), picks (V), date (D) from (P) menu (I)). Objects become classes and Verbs and prepositions become operations done to those classes. Subjects input and receive outputs to the system

What is the connection between use case descriptions and OOAD:

Through the SVDPI's identification of objects and methods

extend, include, generalization

Types of relationships between Primary and Secondary Use Cases:

Generalization use case:

a secondary use case describing the functionalities to be inherited by specialized use cases.

Wrapper:

an object that "wraps around" a legacy system so that a new system can send and receive messages from a legacy system; one way to do integration

Subject boundary:

box drawn around use cases to define the scope of the system; name of system is included in the boundary.

Future trends in UX Design:

content breaks free from delivery media container, blurring software and hardware, build based on UX design, not on hardware constraints, video no longer an exclusive time-based feature (e.g, not at noon on Channel 2), new formats such as live streaming 360 videos, getting used to interactions with AI-driven devices (e.g., Amazon echo, chat bots), from end-to-end customer journey & monetization to learning from consumers within an ecosystem, integrate CRM with marketing, more diversified creative audience, physical and digital world integrated with the next screen is no screen since screen is everywhere.

Use Case Description:

document containing all the information needed to describe the functionality of the business process involved in the use case; must be complete enough for programmers to create the structural (e.g., class diagram) and behavioral model (e.g., sequence diagram). Includes 3 parts: overview information, relationships and the flow of events described in SVDPI.

The 3 Design Strategies once the functional requirements are determined:

inhouse, Packaged software, and outsource

UML:

language of formats, models, and diagrams for doing OOAD. Consists of descriptions of system behaviors (e.g., sequence diagram, activity diagram, use case descriptions) and system structures (e.g., classes and packages)

Primary use cases:

major use cases that provide benefits to an actor

Systems Integration:

process of building new systems by combining packaged software, legacy systems, and new software written to integrate these

UxDesign:

provides mindset for brands to develop their own multi-platform curation ecosystem; an architecture that must interface with third party APIs from GAFA or Asia. Example: Amazon contains device, content, media, social, products and stores vs HBO isn't demonstrating UX Design because it delivers a single type of content (video) with a specified price at entry on one specific TV platform.

Use Case Associations

relationships which show which use cases the actors interact, representing typically a 2-way communication

Actor

someone (or occasionally some thing) outside the system that plays a role interacting with the system.

Secondary use cases:

use cases that depicts specialized modifications to the functionality of a primary use case.