Assignment 1 Solutions:

Part I:

a) The major phases in the waterfall model are: Requirements Analysis, Design, Implementation,
Testing, and Maintenance. The Design phase typically consumes the maximum effort for developing a
typical software product.

b) For a well-understood data processing application, the Waterfall model would be suitable.

For the graphical user interface part of a large software product, an Iterative model would be more
appropriate.

For an extremely large software for cellular communication using satellites, the Spiral model would
be the best choice due to the high risk and need for frequent reassessment.

c) A prototype is a preliminary model of software or part of software that allows stakeholders to

visualize and provide feedback on requirements. It is beneficial to construct a prototype when
requirements are unclear, to explore design alternatives, or to validate requirements with the
customer/user.

Part II:

a) The Spiral model is considered a meta-model because it integrates different models and allows for
iterative development and risk management. It has four main phases: Planning, Risk Analysis,
Engineering, and Evaluation, which can be repeated in an iterative spiral.

Part III:

a) The Scrum Agile model is an iterative and incremental approach to software development. It
emphasizes close collaboration between cross-functional teams, iterative development cycles (called
Sprints), regular meetings, and continuous improvement. Key roles in Scrum include the Scrum
Master, Product Owner, and Development Team.

b) The Iterative Waterfall model is an enhanced version of the Waterfall model, where each phase is
divided into smaller iterations or cycles. It allows for feedback and refinement after each iteration.
The V-model, on the other hand, is a variation of the Waterfall model that emphasizes testing at each
phase, with corresponding test phases on the opposite side of the "V" shape.

Assignment 2 Solutions:

Part I:

a) Requirement analysis is the process of defining and documenting the requirements for a software
system. Activities carried out in requirement analysis include eliciting and gathering requirements,
analyzing and prioritizing requirements, documenting requirements, and validating requirements
with stakeholders.

b) SRS stands for Software Requirements Specification. Three characteristics of a good SRS are:
Completeness (includes all requirements), Consistency (no contradictory requirements), and
Traceability (each requirement can be traced to its origin and related requirements).

c) Functional requirements specify the functional behaviors or services that the software system
should provide, while non-functional requirements specify the constraints, qualities, or attributes
that the software system should possess, such as performance, security, usability, and reliability.

Part II:

a) Functional requirements for "Withdraw money from ATM" could include:

- Authenticate user (e.g., with card and PIN)

- Display available balance

- Allow user to enter withdrawal amount

- Dispense cash if sufficient balance and valid withdrawal amount

- Update account balance and transaction history

- Print receipt

Part III:

1b) Decision Table for Library Membership Automation System:

Request Type Action

Add New Member Create member record <br> Generate bill for annual fee

Renew Membership Update expiry date <br> Generate bill for annual fee

Cancel Membership Delete member record <br> Print cheque for balance amount

Other Flash error message

Assignment 3 Solutions:

Part I:

a) A context diagram is a high-level data flow diagram that shows the overall system as a single
process and its interactions with external entities. For a tic-tac-toe game between a computer and a
human, the context diagram could include:
- External entities: Human Player, Computer

- Data flows: Move (from Human Player to System), Move (from Computer to System), Game Result
(from System to Human Player and Computer)

b) During the design phase, the following items are designed and documented:

- Software architecture and high-level design

- Detailed design of components/modules

- User interface design

- Database design

- Test plans and test cases

c) Coupling refers to the degree of interdependence between software modules or components.

Types of coupling include:

- Tight/High Coupling (e.g., Content Coupling, Common Coupling)

- Loose/Low Coupling (e.g., Data Coupling, Stamp Coupling)

The most desirable type of coupling is Loose/Low Coupling, as it promotes modular design and easier
maintenance.

Part II:

a) DFD (Data Flow Diagram) is a graphical representation of the flow of data through a system,
showing the processes, data stores, and external entities involved. Symbols used in DFDs include:

- Process (rectangle): Represents a transformation or operation on data

- Data Flow (arrow): Represents the movement of data

- Data Store (open rectangle): Represents a storage location for data

- External Entity (square): Represents a source or destination of data outside the system

Part III:

a) Structured analysis and design is a traditional approach to software development that focuses on
breaking down a system into smaller, more manageable components or modules, and representing
the system using structured techniques like data flow diagrams, entity-relationship diagrams, and
structure charts. Major activities include:

- Requirements analysis and modeling

- System design (architectural and detailed design)

- Implementation and testing

b) (Solution not provided in the document)

In this DFD:

Diagram

- The Context Diagram (Level 0) shows the overall Library Management System and its interactions
with external entities: User and Librarian.

- The Level 1 DFD breaks down the system into three main processes: Membership Management,
Book Management, and Update Catalog.

- The Membership Management process handles new membership details from the User and
updates membership status.

- The Book Management process handles book requests/returns from Members and updates book
availability.

- The Update Catalog process updates the library catalog based on book availability and membership
status changes.

- Data stores are represented by the "Member" and "Librarian" entities, which store membership
details and book details, respectively.

Note: This is a simplified representation, and the actual DFD for a real-world library management
system may include additional processes, data stores, and data flows depending on the specific
requirements and features of the system.

Assignment 4 Solutions:

Part I:

a) For the program unit that computes the square root of an input integer in the range of 0 to 5000:

Equivalence classes:

- Valid input: 0 <= input <= 5000

- Invalid input: input < 0 or input > 5000

Black-box test suite:

- Boundary value tests: 0, 1, 5000, -1, 5001

- Equivalence partitioning tests: a few values from each equivalence class

b) Mutation testing is a fault-based testing technique that introduces small syntactic faults
(mutations) into the program code to create mutants. The purpose is to design test cases that can
detect and kill these mutants, ensuring the thoroughness of the test suite.

c) Regression testing is the process of retesting previously tested software after modifications, to
ensure that existing functionality still works as expected. Its purpose is to uncover any unintended
side effects or regression faults introduced by the changes.

Part II:

a) The purpose of integration testing is to verify that different modules or components of a software
system work correctly when integrated together. Approaches to integration testing include:

- Big Bang Integration: All components are integrated together at once

- Top-down Integration: Higher-level components are integrated first, followed by lower-level

components

- Bottom-up Integration: Lower-level components are integrated first, followed by higher-level

components

- Sandwich Integration: A combination of top-down and bottom-up approaches

Part III:

a) Mutation testing is a fault-based testing technique that involves introducing small syntactic faults
(mutations) into the program code to create mutants. Test cases are then designed and executed to
detect and kill these mutants. If a test case can distinguish the behavior of a mutant from the original
program, the mutant is considered "killed." The goal is to design a comprehensive test suite that can
kill as many mutants as possible, ensuring the thoroughness of the testing process.

b) Code review is a systematic process of examining source code to detect defects, identify potential
issues, and ensure compliance with coding standards and best practices. The code review process
typically involves the following steps:

1. Preparation: Select the code to be reviewed and assign reviewers.

2. Overview: The author provides an overview of the code to the reviewers.

3. Individual Review: Reviewers independently examine the code and document their findings.

4. Review Meeting: Reviewers discuss their findings with the author, who addresses the issues or
provides explanations.

5. Rework: The author makes necessary changes based on the review feedback.

6. Follow-up: If needed, a follow-up review is conducted to verify the changes.

Code reviews can be conducted manually or with the help of tools, and they can be formal or
informal, depending on the project requirements and team preferences.

Assignment 5 Solutions:

Part I:

a) Software maintenance is the process of modifying and updating software systems after they have
been deployed and put into operation. Different types of software maintenance include:

- Corrective Maintenance: Fixing defects or errors in the software

- Adaptive Maintenance: Modifying the software to adapt to changes in the environment or

requirements

- Perfective Maintenance: Enhancing the software's functionality or performance

- Preventive Maintenance: Improving maintainability and reliability to prevent future issues

b) Cyclomatic complexity is a software metric that provides a quantitative measure of the logical
complexity of a program's control flow. It directly measures the number of linearly independent
paths through the program's source code, indicating the complexity of the program and the effort
required