Computer
Science Department
Courant
Institute of Mathematical Sciences
Course Title: Adaptive Software
Engineering Course Number: g22.3033-007
Instructor: Jean-Claude Franchitti Session: 5
Session 5: Team Assignment – Application
Modeling Review
Goal
This is an integrated team assignment intended as a review of
the application modeling techniques covered in the course.
Team Setup
You are to work on this assignment with your team.
Overview
As part of this team assignment you will review how to establish the high-level requirements for a software product, take a set of requirements and translate them into Use Cases, review the use UML diagrams (class, sequence, and collaboration) with a UML design tool, enhance your familiarity with the use of UML in code design, and conduct a high-level Design Review. You may either of Rational Rose or Poseidon to submit your answers to the assignment activities.
Assignment Activities
1.
Activity #1
Purpose of this exercise: Establish the high-level requirements for a software product
Problem: You are to determine the user requirements for a web phone-mail product. The primary purpose of this product is to give phone-mail users (e.g., faculty and staff) the ability to access the functionality of the phone-mail system from a web page. In general, the product should enable users of the phone-mail system to do their usual phone-mail activities via a web page. You will need to determine what are those activities, in the form of product requirements.
Customer:
You will need to assume the role of an hypothetical
customer to identify the important user-level requirements. You will also
need to assume the roles of engineer and user in order to develop the full
requirement specification.
See the requirements
supplement for an outline of what
you need to do.
1.
Determine
requirements for the web phone-mail interface. This should include any requirements
that you think are necessary or very desirable in order to meet the customer
needs. If you have a question about what the customer needs (or anything
else), ask the instructor. The initial requirements should include 10
functional requirements and 10 nonfunctional requirements.
2.
Evaluate these
requirements. Do your requirements satisfy the eight criteria: Understandable,
Verifiable, Independent of implementation, Consistent, Complete, Unambiguous,
Realistic, Necessary? Explain your
answers. Weed out any requirements that you do not think are good user
requirements.
3.
Prioritize the
requirements as to whether they are (1) absolutely necessary, (2) desirable, or
(3) optional.
4.
Assume there is a
development team of 5 programmers and this product is to be delivered in 6
months. What are the primary risks associated with implementing a product
that meets your requirements?
5.
System
requirements. Pick one of your user requirements, and translate it into a
list of system requirements. These should be specific enough that the
engineering team can design the software that will meet these requirements.
What to hand in: You should submit your responses to the above 5 questions in one
document.
How To Submit
Turn in a model file called
“tass4_5-act1” with the appropriate extension.
2.
Activity #2
Purpose of this exercise: Take
a set of requirements and translate them into Use Cases. To improve your
understanding of the process, this process will be performed as a
"Design Studio".
Background: You
may find it useful to refer to your answers to activity #1 above. You
should use the requirements gathered for that same application, the web
voice-mail interface. However, in this activity you need to develop use
cases (instead of requirements lists) to express those requirements.
Problem:
Working with your assigned group, perform the following:
- Determine the actors, i.e. any
outside entities (people, systems, etc.) that interact with the web
voice-mail system. Note the following:
- Actors are not
necessarily people! They can be physical devices, other software
systems, etc. Identify two or more different human actors (note
that they need to have different roles!) as well as three or more
non-human actors.
- Actors are external
to the system.
- Include only actors
that are on-stage (primary or secondary).
Don’t include offstage actors.
- Identification of Use
Cases: Provide a name and a one-sentence description of four or more
use cases that describe the functioning of the system. Identify
which actors are primary and which are secondary in each use case. Use cases are behaviors of the system
that meet some need of the primary actor.
Note:
To determine the use cases and actors, it may be helpful to ask some of
the following questions:
o
Who uses the system?
o
Who installs the system?
o
Who starts up the system?
o
Who maintains the system?
o
What other systems interface with this
system?
o
Who provides information to the system?
o
Who extracts information from the system?
o
Does this system do anything
automatically at preset times?
- Goal. For each of the use
cases, specify a purpose in the sense that the primary actor will be
trying to achieve that goal.
- Use case diagrams. Draw a
use case diagram that includes these use cases and the actors you have
specified. Arrows are used indicate an initiator of
activity. They point from primary actors to the use case, and
they point from the use case to its secondary actors.
- Use case relationships.
Consider the use cases and actors you have specified. Indicate any
generalizations of use cases or actors. Identify include and extend
relationships, where they exist, and specify these in the use case
diagrams. If no include or extend relationship exist, then so
indicate.
- Pre- and Post-conditions:
Identify any requirements as to what the system state must be at the start
and at the end of each use case.
- Scenarios. Pick two of the use
cases that you think are most frequently used. Make sure that
neither of these is included in the other. Identify a basic sequence of
steps (main success scenario) that would be followed in normal operation,
and, separately, the various alternative sequences of steps (alternative
paths) that can occur. Your main success scenario should have 8 or
more steps.
What to hand in: Each student should submit his own version of this
exercise. This can be done on paper or electronically (e.g. in a word
document). Specify the names of the students who participated with you in
the exercise.
How To Submit:
Turn in a model file called “tass4_5-act2” with the
appropriate extension.
3.
Activity #3
Purpose of this exercise: Become familiar with the use of UML in code
design
Problem: You need to implement a "Book Order
Application" to be used to process book purchases.
This application is to be used to enable users (these are sales reps for the
bookstore) to process orders for books. You are responsible for
making sure your application supports the following use case:
Use Case: Process
customer order
Actors: Sales Rep
(person), Inventory Management System (software), Billing Dept
(person).
Precondition: A customer
has requested to order a book, and Sales rep starts Book Order Application
Main Success Scenario:
- User (Sales Rep) is told to specify Book Title.
- User enters Title.
- Application queries InventoryManager
determining if Title is in catalog
- If Title is in catalog, Application queries InventoryManager
to determine the ISBN, the price of the book, and the number of copies in
stock.
- Application reports the book price and the number of copies in
stock to the User
- Application requests the number of copies to be ordered.
- User enters the number of copies.
- Application requests the name and address to ship the books.
- User enters name and address.
- If all the needed books are in-stock, Application submits a
shipping order for the books to the specified address. This order
will update the inventory.
- Application creates a book order, specifying the shipping name and
address, the number of copies of the book that were backordered and the
number that are being shipped, as well as the total cost of the books
being shipped. This information is displayed to the user.
Alternate Scenarios:
- If Title is not in catalog in step 3, Application reports this
fact to User, and terminates.
- In step 7, if the number of copies is less than or equal to 0, the
Application terminates.
- In step 10, if some (but not all) of the required books are
in-stock, Application submits a shipping order for just the copies of the
book that are in-stock. This order will update the inventory.
- In step 10, if not all the required copies are in stock,
Application submits a back order (to the Inventory Manager) for the number
of additional copies that are needed. This backorder will update the
inventory.
The following UML Activity
Diagram is provided to describe this use case:
The Inventory Management System
has already been implemented. You can obtain the Inventory Management
Code (inventoryManager.cpp, inventoryManager.h) and the Book Inventory Database
file (CatalogList.txt) from the website. The CatalogList.txt file will
need to be put in the directory where your application is launched so that it
can be read at startup time.
Note: One problem you
will encounter is to read an input line of text from the console (including
blanks) when the user inputs a book title. There is (commented-out) test
code in inventoryManager.cpp that provides one way of
reading this input line. This can also be done with the iostream classes.
Your assignment is the
following:
- Draw a UML Sequence Diagram to illustrate the above use
case. The classes in this diagram should include "InventoryManager" (The inventory management class
that has been provided for you), "SessionManager"
(The class that reads and writes console messages), and "BookOrder", a class that contains the information
associated with this order (the book title, the ISBN, the number to be
shipped, the number back-ordered, the shipping name and address, and the
total charge). Add any additional classes you think appropriate.
- Draw a UML Class Diagram that illustrates the classes and their
associations.
- (optional) Implement the "SessionManager"
class, the "BookOrder" class and other
classes you are using, not including "InventoryManager"
- (optional) Write a short main (driver) program that just creates
your SessionManager, then runs it until it
completes. Your driver routine should not do any of the work of the
application.
- (optional) Compile and build a working executable using your
driver, SessionManager, BookOrder, and the provided InventoryManager,
that performs the required tasks..
What to
hand in: Provide a
UML sequence diagram, A UML class diagram, plus (optional) working code that implements your diagrams. Submit this along with
an (optional) script of a session where you have submitted a book order that
can only be partially shipped. You may use either Windows or Linux for
this exercise (as needed). Submit your software, diagrams, and (optional)
results in a model file called “tass4_5-act3” and (optional) code and session
capture files with the appropriate extension
4. Activity #4
Purpose of
this exercise: Learn how to conduct a high-level Design Review
Problem:
Consider the Online Flight Reservation system, the subject of activity #3.
You are to participate in a Design Review of the proposed system design.
Based on a Design
Review,
you will evaluate the design, and will determine specific improvements that
must be made to the design. You will evaluate the design by participating
in the presentation and discussion of the design, and by answering the
following questions:
- Does the design meet the
Requirements?
State specifically which (if any) requirements are not met, and propose
corrective action. Note if any of the Use Cases will not function as
expected.
- Does the design include
any unnecessary features? Identify any capabilities that can be
eliminated from the design while still meeting the requirements.
- Is the design adequately
specified? Note any areas where the design has not been sufficiently
explained to perform an evaluation. Note that this is a high-level
design review, the design is not expected to specify all low-level
details.
- Are there significant
design flaws? Identify any parts of the design that are not likely
to function as required. For each such flaw, propose changes that
will address the problem.
- Is the proposed design
well-organized, according to object-oriented principles? Identify
any organizational problems and specify how they should be improved.
- Is the proposed design
likely to be implementable? Note any areas
of the design that will be difficult to implement in a timely fashion, and
propose improvements that will resolve these difficulties.
- Usability: Will
the proposed design enable users to easily perform all needed
functionality? Identify any problem areas and propose improvements.
What to hand in: Provide complete answers to the above
questions. Turn in a file called “tass4_5-act4” with the appropriate
extension.
Grade Computation
Grade Breakdown:
- Team Assignment
participation: 5 points
- Activity
- Activity
- Activity
- Activity