PART C :

1.The software development process is a complex and iterative process that consists of
multiple phases. The phases may vary depending on the type of software being developed,
but generally,
there are five phases in the software development process:

Requirements Gathering: In this phase, the software development team gathers and
analyzes the requirements for the software. The team works with the client or end-users to
determine their needs and expectations for the software.

Design: In this phase, the software architecture is designed. The software development
team
creates a high-level design that shows how the software will be structured, what its
components will be, and how they will interact with each other.

Implementation: In this phase, the software development team writes code and develops
thesoftware. The team follows the design plan and writes code that meets the requirements
set in the previous phases.

Testing: In this phase, the software is tested to ensure that it meets the requirements and
specifications. The software is tested at different levels, from unit testing to system testing.

Maintenance: In this phase, the software is maintained and updated to meet changing
needs
or to fix bugs or errors that are discovered over time.

For railway reservation software, the software development team can use the Waterfall
model, which is a linear sequential approach to software development. The Waterfall model
consists of the following phases: Requirements, Design, Implementation, Testing, and
Maintenance. This model is well-suited for railway reservation software development
because the requirements are well-defined, and the software development process is a
linear sequence.
In conclusion, the software development process is an essential part of developing software,
and it involves multiple phases. The choice of software life cycle model depends on the type
of software being developed. For railway reservation software, the Waterfall model is a
suitable option.

PART C 3
Explain the benefits and concepts of use case and use case model and analyze the relating
use cases have in ATM system

Use case is a technique used in software development to capture the requirements of a

system from the perspective of an end-user. It is a description of how an actor (user)
interacts with the system to achieve a specific goal. A use case model is a collection of use
cases that describes the functionality of a system. The benefits and concepts of use case
and use case model are:

Benefits of Use Case and Use Case Model:

User-Centered: Use cases focus on the end-users and their needs, which helps ensure that
the system meets the user's requirements.
Clear Requirements: Use cases provide clear and concise requirements for the system,
making it easier to understand the system's functionality and what it needs to do.
Communication: Use cases help to facilitate communication between stakeholders,
including
developers, designers, and users, which can help to avoid misunderstandings and ensure
that everyone is on the same page.
Flexibility: Use cases are flexible and can be adapted as requirements change, making them
useful in agile development environments.
Concepts of Use Case and Use Case Model:
Actor: An actor is a person or system that interacts with the system being developed.
Use Case: A use case is a description of a specific interaction between an actor and the
system.
Scenario: A scenario is a sequence of steps that describes how an actor interacts with the
system to achieve a specific goal.
System Boundary: The system boundary defines the boundaries of the system being
developed and the actors that interact with it.

PART C 6
There is a class called Course, which had a method that creates
Section objects.
Modify the two classes so that (a) Course class maintains the list
of all sections. (b) Section stores the capacity and the number of
students enrolled in the class. (c) Course has a search facility that
returns a list of courses that are not full.

Class Course {
private ArrayList<Section> sections;

public Course() {
this.sections = new ArrayList<Section>();
}

public Section createSection(int capacity) {

Section section = new Section(capacity);
this.sections.add(section);
return section;
}

public ArrayList<Section> findNotFullSections(){

ArrayList<Section> notFullSections = new ArrayList<>();

for (Section s : this.sections) {

if (s.getEnrolledStudents() < s.getCapacity()) {
notFullSections.add(s);
}
}

return notFullSections;
}
}

Class Section {
 private int capacity;
private int enrolledStudents;

public Section(int capacity) {

this.capacity = capacity;
this.enrolledStudents = 0;
}

public int getCapacity() {

return this.capacity;
}

PART C 8
In the case of library management system, the system displays
the transaction details with each book. Modify this so that there is
only one display of transactions at the end of the process.

To modify the library management system to display only one transaction at the end of the
process, the system would need to be updated to store each transaction in a single data
structure. This data structure would need to contain the details of each transaction and be
updated as new transactions occur. At the end of the process, the system would then iterate
through the data structure and display all the transaction details at once.

In an ATM system, some of the use cases include:

Withdraw Cash: The user wants to withdraw cash from their account using the ATM.
Check Balance: The user wants to check the balance of their account using the ATM.
Transfer Funds: The user wants to transfer funds between accounts using the ATM.
Change PIN: The user wants to change their PIN using the ATM.
Each of these use cases would have a specific scenario that outlines the steps the user
needs to take to achieve their goal. By using a use case model, developers can ensure that
all of the necessary use cases are considered and that the system meets the needs of the
end-users. Additionally, the use case model can help to identify potential problems or areas
where the system could be improved to provide a better user experience.

PART B 1
Identify the players who would have a stakeholder in software
development process. What are the concerns of each? How
would they benefit from the object-oriented model?

1. End Users: End users have a stake in software development processes as they are the
ones who will be using the software. Their concerns are that the software meets their needs,
is easy to use, and provides value. They would benefit from an object-oriented model
because it allows for greater flexibility and customizability to meet their needs.

2. Project Managers: Project managers have a stake in software development processes as

they are responsible for ensuring that the software is developed on time, within budget, and
meets the needs of the end users. Their concerns are that the software meets the project
goals and is delivered on time. They would benefit from an object-oriented model because it
can help them better manage the complexity of software development by allowing for a
modular approach to creating code.
3. Developers: Developers have a stake in software development processes as they are
responsible for writing the code that will make up the software. Their main concern is that
the code they write is robust, efficient, and secure. They would benefit from an object-
oriented model because it provides a structure and framework for writing code that is easier
to understand and maintain.

4. Testers: Testers have a stake in software development processes as they are responsible
for ensuring that the code works as expected and does not contain any bugs or flaws. Their
main concern is that the software is free of defects and performs as expected. They would
benefit from an object-oriented model because it allows for easier testing of individual
components of the software.

5. Business Analysts: Business analysts have a stake in software development processes as

they are responsible for understanding the goals of the project and ensuring that the
software meets those goals. Their main concern is that the software meets the needs of the
end users and provides value to the organization. They would benefit from an object-
oriented model because it allows them to better understand the structure of the code and
ensure that the software meets the needs of the end users.

PART B 2
Consider an application that you are familiar with, such as a
university system. Divide the entities of this application into
groups, thus identifying the classes.

Classes:
1. Student:
- Personal Information (Name, Address, Phone, etc.)
- Course Selection
- Financial Aid
- Progress Reports
- Grades

2. Faculty:
- Personal Information (Name, Address, Phone, etc.)
- Course Assignment
- Class Schedules
- Grades

3. Administrator:
- User Accounts
- Student Records
- Faculty Records
- Course Catalog
- Financial Aid

4. Courses:
- Course Name
- Course Description
- Prerequisites
- Credits
- Faculty Assigned
5. Registration:
- Student Enrollment
- Course Selection
- Payment
- Academic Records

6. Financial Aid:
- Eligibility Requirements
- Application Process
- Awards
- Grants
- Loans

7. Library:
- Books
- Journals
- Magazines
- Reference Materials
- Archives
- Digital Media

8. Campus Services:
- Campus Security
- Food Services
- Student Activities

PART B 3
Think of some common businesses and the activities software
developers are involved in. What are the sets of processes they
would like to automate? Are there any that need software just for
one process?

1. Retail: Automating the checkout process, inventory management, order processing,

customer service.

2. Banking: Automating loan processing, account management, fraud detection, customer

service.

3. Healthcare: Automating patient records management, billing, scheduling, appointment

reminders.

4. Manufacturing: Automating production processes, inventory management, quality control,

scheduling.

5. Logistics: Automating package tracking, shipment routing, delivery management.

Yes, there are processes that need software just for one process. For example, a company
may need software to automate its payroll process, or software to automate its
marketing campaigns.
PART B 4
Suppose all the code is given (corresponding to all of the classes)
into one single class. What happens to cohesion and coupling?

The cohesion and coupling of the code would both decrease. This is because the code would
be less organized and modular, making it harder to understand and maintain. As a result, it
would become less cohesive and more coupled, as the code would be more intertwined.

PART B 5
Differentiate object oriented methodology from structural
methodology.

Object Oriented Methodology: Object Oriented Methodology is a software development

approach that focuses on creating reusable objects and data structures. It is a set of
principles, languages, and tools that enables developers to create programs that are
organized around objects and data. The main focus of Object Oriented Methodology is to
create objects that represent real world entities and can be manipulated through code.

Structural Methodology: Structural Methodology is a software development approach that

focuses on creating a structure for the program. It is a set of principles, languages, and tools
that enables developers to create programs that are organized around a data structure. The
main focus of Structural Methodology is to create a structure for the program that is
organized and consistent.

PART B 6

Various software process models are developed for software

development. What is the need of Unified Process?

The Unified Process (UP) is an iterative and incremental software development process
framework based on unified methodology. It was created to provide organizations and
software development teams with a comprehensive process framework that is easy to
understand and apply. The UP provides a standard set of best practices and processes that
can be tailored to fit the specific needs of different projects and organizations. By providing
a consistent process, the UP helps reduce the amount of time and effort required to develop
software by eliminating the need to reinvent the wheel each time a new project is started.
Additionally, the UP helps to ensure the quality of the software developed by providing a set
of structured processes for the entire lifecycle of a project.

PART B 7
Unified Process model and COMET process model are used for
software development. Find out the common features of both the
model. Also, identify the differences.

Common Features:
1. Both the models are iterative and incremental in nature.
2. Both the models involve the creation of a software product that meets the requirements
of the customer.
3. Both the models involve the use of a team of professionals, such as developers, designers,
testers, and project managers.
4. Both the models involve the use of a formal set of processes and activities, such as
requirements gathering, design, coding, testing, and deployment.

Differences:
1. The Unified Process model is a more comprehensive and structured approach to software
development than the COMET process model.
2. The Unified Process model has a greater emphasis on the use of modern software
engineering techniques, such as object-oriented programming and the use of design
patterns.
3. The COMET process model has a more lightweight, agile approach to software
development, with less emphasis on the use of formal processes and activities.
4. The Unified Process model has a greater emphasis on the use of formal project
management techniques, such as project scheduling and risk management.
5. The COMET process model has a greater focus on the use of collaboration tools, such as
wikis and group messaging

Part b 8.
Draw and analyze the use cases in PAY ROLL system.

Use case 1:

Actors: Human Resources Manager, Payroll Clerk

Description: The Human Resources Manager enters employee information into the PAY ROLL
system. This includes employee name, address, salary, taxes, deductions, and other
necessary information.

Preconditions: The Human Resources Manager has entered all necessary employee
information.

Postconditions: The employee information is stored in the PAY ROLL system.

Use case 2:

Actors: Payroll Clerk, Employee

Description: The Payroll Clerk processes the employee payroll information, calculates taxes,
deductions, and other necessary information.

Preconditions: The Payroll Clerk has all necessary employee information.

Postconditions: The payroll is processed and the employee’s salary, taxes, and deductions
are calculated.

Use case 3:

Actors: Payroll Clerk, Employee

Description: The Payroll Clerk generates a paystub for the employee based on the
information entered in the PAY ROLL system.
Preconditions: The Payroll Clerk has all necessary employee information and the payroll has
been processed.

Postconditions: The paystub is generated and sent to the employee.

Part b 9. AND PART C 9

Let’s consider an ATM system function. If the user enters the
invalid password more than three times then the account will be
locked. In this system, if the user enters a valid password in any
of the first three attempts, then the user will be logged in
successfully. If the user enters the invalid password in the first or
second try, then the user will be asked to re-enter the password. And finally, if the user
enters incorrect password for the
third time, then the account will be blocked. Draw an activity
diagram for the given scenario.

[Activity Diagram]

Start
|
|
|
V
Enter Password
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
V
Password Incorrect?
/ \
/ \
/ \
Y N
| |
| |
| |
 V V
Login Successful Attempt 2
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
V V
Password Incorrect? Password Incorrect?
/ \ / \
/ \ / \
Y N Y N
| | | |
| | | |
V V V V
Login Successful Attempt 3 Account Locked
|
|
|
V
End

PART B 10
Draw a use case diagram that represents the working of HTML5
video player in the browser

[![Use Case Diagram for HTML5 Video Player in Browser][1]][1]

[1]: https://i.stack.imgur.com/4q3qF.png

PART B 11

Consider a library management system. Perform object oriented

system development and give the use case diagram (use include,
extend and generalization)

Use Case Diagram

[![Use Case Diagram for Library Management System][1]][1]

[1]: https://i.stack.imgur.com/9fzYs.png

PART B 12
How do you indicate that a member is static in a UML Class
Diagram?

A static member in a UML Class Diagram is indicated by an underline beneath

the member name.

PART B 13
A manager at a small zoo instructs the zoo-keeper to ‘feed the
animals’. Explain how a proper completion of this task by the
zoo-keeper implies that the zoo operations are implicitly
employing the concepts of inheritance, polymorphism and
dynamic binding.

Inheritance: The zoo-keeper needs to understand the different types of animals in the zoo,
and the specific dietary needs of each type. This implies that the animals are organized into
classes of animal types, with each class inheriting the dietary needs of its parent class.

Polymorphism: Depending on the animal, the zoo-keeper will need to provide different
types of food. This implies that the zoo-keeper needs to account for the polymorphism of
different types of animals and the different types of food they require.

Dynamic Binding: The zoo-keeper also needs to understand the particular needs of each
individual animal, which implies that they are dynamically binding the dietary needs of each
animal to the specific animal in question.

UNIT 2

PART B
1.Differentiate static and dynamic models. What would be preferred
in order to make an effective design?

Static models are mathematical or physical models that are developed to describe a system
at a certain point in time. These models are used to describe the system’s structure and
behaviour, but they do not account for changes in the system over time. Dynamic models
are mathematical or physical models that are developed to describe a system over a period
of time. These models are used to describe the system’s structure and behaviour, and they
also account for changes in the system over time.

The preferred model for an effective design depends on the application. For example, static
models are often used for static systems such as bridges or buildings, where the structure
and behaviour of the system does not change over time. Dynamic models are often used for
dynamic systems such as weather systems or economic systems, where the structure and
behaviour of the system can change over time.

2.Differentiate OO Analysis and OO Design? Does both analysis

and design should go together? Is analysis or design alone quite
sufficient to construct a software system. Justify from your
perspective.
Object-oriented analysis (OOA) is the process of gathering requirements and analyzing a
problem to be solved with object-oriented programming. It involves understanding the
system and its environment, analyzing the problem and defining the objectives of the
system. OOA helps to identify business objects and the relationships between them that can
be used to build a software system.

Object-oriented design (OOD) is the process of transforming the requirements and analysis
into a working software system. It involves designing the architecture and components of a
system, and developing the classes and objects needed to implement it. OOD helps to define
the interfaces and interactions between objects that will be used in the software system.

Both analysis and design go together in order to construct a software system. Analysis is
needed to understand the problem and define the objectives, while design is needed to
translate the analysis into a working software system. Analysis alone is not sufficient to
construct a software system since it does not provide the details of how the system should
be implemented. Similarly, design alone is not sufficient since it does not provide the
necessary understanding of the problem and objectives.
3.Draw the CRC Card template and with an example.

CRC Card Template

Class Name:

Responsibilities:

Collaborators:

Example

Class Name: Online Shopping Cart

Responsibilities: Calculate total cost, add items to the cart, remove items from the cart,
display the list of items in the cart

Collaborators: Customer, Payment Processor, Shopping Website

4.With a neat diagram explain the steps involved in Use Case Driven
Object-Oriented Analysis. Indicate how an analysis would help the
design part to remain steady and mention strongly that design part
would make use of the analysis to create a system.

_________________________
| |
| Use Case |
| Driven |
| Object-Oriented |
| Analysis |
| |
------------------------
|
|
|
 |
|
V
--------------
| |
| Modeling |
| |
--------------
|
|
|
|
|
V
------------------------
| |
| Class, Sequence, & |
| Interaction Diagrams |
| |
------------------------
|
|
|
|
|
V
------------------------
| |
| Object Modeling |
| |
------------------------
|
|
|
|
|
V
------------------------
| |
| System Design & |
| Implementation |
| |
------------------------

The Use Case Driven Object-Oriented Analysis (UCODOA) process is a

methodology that helps to create a system that is based on the user’s
needs and requirements. It involves the following steps:

1. Use Case Modeling: In the first step, use cases are identified which
describe the behavior of the system from the user's point of view.
2. Class, Sequence, and Interaction Diagrams: The use cases are then
used to create class, sequence, and interaction diagrams which help
to identify the objects and their behavior in the system.

3. Object Modeling: In this step, the objects are modeled and their
relationships are identified.

4. System Design & Implementation: In this final step, a system

design is created based on the object model and the system is
implemented.

By following the UCODOA process, the design part of the system

remains steady as the analysis part is done beforehand. This ensures
that the design part makes use of the analysis to create a system
that meets the user’s needs and requirements.
5.With suitable example define aggregation relationship in class
diagram. Indicate how aggregation alone would play a major part
when compared to its other counterpart. Bring the strong points of
aggregation and justify them with a real time example.

Aggregation is a special type of association in which one class is a part of another class. The
part class in an aggregation relationship is called the "child" class, while the class that
contains the part is called the "parent" class. In the class diagram, the aggregation
relationship is represented by a line connecting two classes, with an empty diamond at the
parent class end.

A real-world example of an aggregation relationship is a car and its parts. A car has many
parts, such as a steering wheel, engine, and wheels. The car is the parent class, while the
parts are the child classes.

Aggregation has several advantages compared to its counterpart, Composition. The main
advantage is that a child class in an aggregation relationship can be part of more than one
parent class. For example, a steering wheel can be part of multiple cars. This allows for the
reuse of parts between different parents. Additionally, an aggregation relationship is less
restrictive than a composition relationship, allowing the child class to exist without the
parent class.

In summary, Aggregation is a specialized type of association in which one class is a part of

another class. It allows for the reuse of parts between different parents and is less restrictive
than composition.
6.List out the design corollaries.

1. Design for the user, not for yourself.

2. Never stop learning and evolving your design skills.
3. Simplicity is key.
4. Use the best tools available.
5. Focus on the details.
6. Leverage feedback from users.
7. Keep up with the latest trends.
8. Prioritize accessibility.
9. Build a strong portfolio.
10.Test often and early.

7.Differentiate coupling and cohesion. What would be the coupling

and cohesion of good design?

Coupling is the degree to which two separate modules or components of a system are
connected. It is the measure of how dependent one module is on another. Coupling is
usually seen as a bad thing, as it reduces the flexibility of a system and makes it more
difficult to maintain.

Cohesion is the degree to which the elements of a module are related and work together
towards a common goal. It is the measure of how related the components are within a
module. Cohesion is usually seen as a good thing, as it increases the flexibility of a system
and makes it easier to maintain.

A good design will have low coupling and high cohesion. Low coupling between modules
allows for more flexibility and easier maintenance, while high cohesion within modules
allows for better organization and more efficient code.