ASSIGNMENT

.
Q1.

Answer:
Use-Case Specification: Transfer Cash from transaction machine
This use case describes how I will transfer money from a transaction machine in a
super shop using my debit/credit card.

Check Balance

Transfer Funds

Deposit Funds
Myself

(customer)
Withdraw Cash

Bank

Repair

Technician
Maintenance

Preconditions:
• The transaction machine must support transaction for the bank that issued
my card.
• The network connection to the bank system must be active.
 • The account must have least amount of cash that can be transacted.
• The cash transaction service option must be available.
Basic Flow of Events:
Insert Card:
The use case begins when I insert my debit/credit card into the card reader
on the ATM. The system allocates an ATM session identifier to enable
errors to be tracked and synchronized between the ATM and the Bank
System.
Read card:
The system reads the bank card information from the card.
Authenticate Customer:
Perform sub flow authenticate customer to authenticate the use of the bank
card by me using the machine.
Select Transaction:
The system displays the service options that are currently available on the
machine. I will need to select to transfer cash.
Select Amount:
The system prompts for the amount to be withdrawn by displaying the list of
standard transaction amounts. I will select an amount to be withdrawn
Confirm Transaction:
Perform sub flow Assess Funds on Hand.
Perform sub flow Conduct Transaction.
Eject Card:
The system ejects my card.
Dispense Cash:
The system dispenses the requested amount of cash to me. The system
records a transaction log entry for the transaction.
Use Case Ends:
Use case ends.
Sub flows:
 Authenticate Customer:
 Validate Card Information:
The system sends the bank card information to the bank system to
confirm that the card and its associated account are active, that the
card has not been reported stolen and that the bank card information
(including the PIN) read from the bank card is valid.
The system also sends the card ID and the session identifier to the
Bank System along with the bank card information.
The Bank System acknowledges that the bank card information is
valid and that the card can be used.

 Validate User Identity:

The system prompts me to enter the PIN.
I enter the PIN.
The system checks that the PIN entered is identical to the PIN read
from the bank card.

 The flow of events resumes at the next step.

 Assess Funds on Hand:

The system determines whether it has sufficient funds on hand to
dispense the requested amount.
If there are not sufficient funds on hand, the system informs me that the
amount requested is not available from the machine.
I select an amount to be withdrawn.
The flow of events resumes at the next step.

 Conduct Transaction:
1. Validate the Transaction:
The system supplies the bank system with the bank card information,
the amount of the requested transaction, the session Identifier and the
transaction fee and asks it to approve the transaction.
 The bank system responds with a transaction acceptance to approve
the transaction.
Log the Authorization:
The system records a transaction log entry for the authorized transaction
including the information that the cash is still to be dispensed.
Resume at the next step.

Q2.

Answer:
Convincing the customer to agree to every demand that I have as a
developer does not make me a master negotiator.
Conflicts play an important role in software engineering. Software engineering is a
highly collaborative process and identifying shared or opposed interests is a
necessity for project success. The objectives of customers, users, or developers
must be understood and reconciled to develop mutually acceptable agreements.
The result of negotiation is also to understand why stakeholders disagree. The
clients generally have a lack of understandings of software feature and
developments. When the clients of the software project disagree on the
requirements, requirements negotiation methods can be used to reach that
agreement. Negotiation means keeping both side happy on a balanced point. But if
I as a developer convince the client to agree to all my point then there is nothing on
the table that is from the client which represent major risks as in future it will be
hard to convince them if the final product does not feature their understanding of
what they wanted.
A master negotiator does not assume that they know where their style works for
them and where it works against them, they have learned to be flexible with the
clients and must play both sides while creating and claiming value that are at the
heart of the negotiation process.
 The Quality Function Deployment methodology is a 3-phase process
that encompasses activities throughout the product development cycle. Here our
product is a library management system. The 3-phases are described after a
description of current background:

Background:
The library is managed, organized, and run by the librarian. All the functions like
managing books, issuing books, and finding the books for the members is carried
out by librarian. This is where the time and effort are consumed. Whereas the
members also find difficulty in finding availability the books and need the
assistance of librarian in every step. The librarian also finds it tedious if he must
deal with several members at a same time. This is a difficult system. Library is
basically concerned about acquisition, preservation, and administration of its
resources. To carry out these tasks a new system is required.

Normal requirements (Product Definition):

Any library member should be able to search books by their title, author,
subject category as well by the publication date.

Each book will have a unique identification number and other details
including a rack number which will help to physically locate the book.

There could be more than one copy of a book, and library members
should be able to check-out and reserve any copy. We will call each copy
of a book, a book item.

The system should be able to retrieve information like who took a

particular book or what are the books checked-out by a specific library
member.
 There should be a maximum limit on how many books a member can
check-out.

There should be a maximum limit on how many days a member can keep
a book.

The system should be able to collect fines for books returned after the
due date.

Members should be able to reserve books that are not currently available.

The system should be able to send notifications whenever the reserved

books become available, as well as when the book is not returned within
the due date.

Each book and member card will have a unique barcode. The system
will be able to read barcodes from books and members’ library cards.

Expected requirements:
The system should use a secured database and should have multiple
authentication layers to ensure that they are not penetrable.

Member accounts should have access constrictions.

The system should be fast, secure and the graphical user interface should be
very reactive.

The system should be compatible with all existing platforms that can use
web browsers.

The system should have huge data storage capability.

The system should be able to handle expected and unexpected errors.

 The system should only be accessible by those who have a confirmed
member’s account.

There should be distinct administrative accounts that can be used to

administer the system.

The administrator should be able to update members and information about

any book.

Exciting requirements:
1. Members should be able to give feedback about book experiences.

2. The system should inform the admins for any unauthorized login.

3. Passwords can be changed any time.

4. The system should not let members change their information (except
password) without proper authentications and the admins permission.

5. The system should quickly send notifications to a member for any unusual
activities.

6. The database should be maintained through a user-friendly customization.

7. The system should provide an appropriate viewer, book previews before

borrowing.

8. The searching process for books should be instant.

9. The system should be able to routinely backup and restore data if any fault
occurs or the system fails.
Q4.

Answer:
I both agree and disagree with that statement based on the development
model one company or team is pursuing.

I disagree when it decreases the confidence of our clients’ overtime. It is wrong

to think that continuous confidence and quality control does not matter. As
developer we might know what the final product can be based on our
understanding of the development process and in circle planning. But our client
or shareholders might not have an overall understanding of the process. So, a
continuous increment is our only way to build a good trust and collaborative
system.
An effective quality assurance in project is essential to a team that delivers
continuous results. It is an ongoing process which upholds the quality and
productivity of work. Every project requires a quality program to not only measure
how well process is advancing with policies and procedures, but also to ensure
their continuous improvement scenario in the clients’ mind.
Well-designed and properly executed project increments provides several benefits
for a company, its employees, and clients. It builds a performance culture that
showcases the company’s expertise, promotes employee improvement, and leads to
an improved customer experience and higher levels of satisfaction. This strategy
sets out the number and frequency of evaluations, and feedback sessions.
In other sense, the project development model can be an incremental model. The
incremental model is essentially a series of waterfall cycles. The requirements are
known at the beginning of the project and are divided into groups for incremental
development. A core set of functions is identified in the first cycle and is built and
deployed as the first release. The software development cycle is repeated, with
each release adding more functionality until all requirements are met. Each
development cycle acts as the maintenance phase for the previous software release.
While new requirements that are discovered during the development of a given
cycle can be implemented in subsequent cycles, this model assumes that most
requirements are known up front. The effort is planned and executed to satisfy the
initial list of requirements. A modification to the incremental model allows
development cycles to overlap.
In that case, each increment is dependent on the clear execution of previous one or
multiple increment. If the previous increment is not executed with proper quality,
then the whole project may crumble and fail.
So, to uphold the confidence of our clients, works and the proper process
management of a software development process we should deliver much emphasis
in our every increment.

I agree with the statement when most requirements are not known in the beginning,
development is spread out over multiple iterations, interfaces between modules are
not well-defined or operations are impacted as each new increment is deployed. In
this case, it is better to show less concern about quality in the early increments and
give better emphasis on understanding the continuously added requirements.