## Section-A (CO-3)

### Q.1: Attempt any SIX questions. Each question is of two marks. (2 x 6 = 12 Marks)

a) **What is cyclomatic complexity?**

Cyclomatic complexity is a software metric used to measure the complexity of a program. It is

calculated based on the control flow graph of the program, specifically the number of linearly
independent paths through the code. The formula is M = E - N + 2P, where M is the cyclomatic
complexity, E is the number of edges in the control flow graph, N is the number of nodes, and P
is the number of connected components.

b) **What do you mean by Modularization?**

Modularization refers to the process of dividing a software system into discrete modules that can
be developed, tested, and maintained independently. Each module performs a specific function
and interacts with other modules through well-defined interfaces.

c) **What is the difference between Top Down Design and Bottom Up Design?**

Top Down Design starts with the highest level of system functionality and breaks it down into
smaller, more detailed components. Bottom Up Design, on the other hand, begins with designing
the most basic or low-level components first and then integrates them into higher-level
structures.

d) **What is Pseudo Code? How does it differ from an algorithm?**

Pseudo Code is a high-level description of an algorithm that uses the structural conventions of
programming without the syntax. Unlike a formal algorithm, pseudo code is intended for human
reading rather than machine execution and serves as a blueprint for writing the actual code.

e) **What is the software metric?**

A software metric is a measure used to quantify various attributes of software development and
performance. Metrics can include code complexity, lines of code, defect density, and more,
helping in assessing quality, productivity, and progress.

f) **Identify four characteristics of a good Software Design technique.**

1. **Modularity**: Design should break the system into smaller, manageable modules.
2. **Scalability**: Design should allow for future growth and expansion.
3. **Maintainability**: Design should make it easy to update and fix the software.
4. **Reusability**: Components of the design should be reusable in other applications.

g) **What is a Structure Chart?**

A structure chart is a hierarchical diagram used in software engineering to represent the

organization of a system, showing the breakdown of a system into its component functions and
modules.

### Q.2: Attempt any THREE questions. Each question is of 6 marks. (3 x 6 = 18 Marks)

a) **Define Software Design Framework with a neat and clean diagram.**

A Software Design Framework provides a structured approach to software development,

encompassing a set of guidelines, best practices, and tools. It ensures consistency and
completeness in the design process. Components typically include:
1. **Architecture Design**: High-level structure of the system.
2. **Module Design**: Breaking down the architecture into modules.
3. **Data Design**: Defining data structures and databases.
4. **Interface Design**: Designing how modules and components interact.

*Diagram:*
```
+-------------------+
| Architecture |
| Design |
+-------------------+
|
+-------------------+
| Module |
| Design |
+-------------------+
|
+-------------------+
| Data |
| Design |
+-------------------+
|
+-------------------+
| Interface |
| Design |
+-------------------+
```

b) **What do you mean by Coupling? Discuss various types of Coupling.**

Coupling refers to the degree of direct interdependence between software modules. Lower
coupling is usually preferable because it indicates less interdependence, making modules easier
to understand, change, and maintain. Types of coupling include:
1. **Content Coupling**: One module modifies or relies on the internal workings of another.
2. **Common Coupling**: Multiple modules share the same global data.
3. **Control Coupling**: One module controls the flow of another by passing control information.
4. **Stamp Coupling**: Modules share a composite data structure and use only part of it.
5. **Data Coupling**: Modules share data through parameters.

c) **What do you mean by Cohesion? Discuss various types of Cohesion.**

Cohesion refers to how closely related and focused the responsibilities of a single module are.
Higher cohesion within a module is desirable as it signifies that the module is more self-
contained and focused. Types of cohesion include:
1. **Functional Cohesion**: Elements contribute to a single well-defined function.
2. **Sequential Cohesion**: Output from one part serves as input for another.
3. **Communicational Cohesion**: Elements operate on the same data set.
4. **Procedural Cohesion**: Elements follow a specific sequence of execution.
5. **Temporal Cohesion**: Elements are related by timing (executed together).
6. **Logical Cohesion**: Elements are logically categorized to do similar things.
6. **Logical Cohesion**: Elements are logically categorized to do similar things.
7. **Coincidental Cohesion**: Elements have little or no relationship to each other.

d) **Compute the function point value for a project with the following information domain
characteristics:**

- Number of user input (avg) = 32

- Number of user outputs (low) = 60
- Number of user enquiries (high) = 24
- Number of files (low) = 8
- Number of external interfaces (avg) = 2

**Assuming the various complexity adjustment values are average.**

Function Point (FP) calculation involves determining Unadjusted Function Points (UFP) and then
applying a Value Adjustment Factor (VAF).
UFP = (Weighting factors for inputs * number of inputs) + (Weighting factors for outputs *
number of outputs) + (Weighting factors for enquiries * number of enquiries) + (Weighting
factors for files * number of files) + (Weighting factors for interfaces * number of interfaces)

Using typical weighting factors:

- Inputs (avg) = 4 * 32
- Outputs (low) = 4 * 60
- Enquiries (high) = 6 * 24
- Files (low) = 7 * 8
- Interfaces (avg) = 5 * 2

UFP = (4 * 32) + (4 * 60) + (6 * 24) + (7 * 8) + (5 * 2) = 128 + 240 + 144 + 56 + 10 = 578

Assuming an average complexity adjustment factor, VAF is typically around 1.0.

FP = UFP * VAF = 578 * 1.0 = 578

e) **Obtain Halstead's length and volume measure for the following C function.**

```c
void swap(int x[], int a) {
void swap(int x[], int a) {
int tmp;
tmp = x[a];
x[a] = x[a + 1];
x[a + 1] = tmp;
}
```

**Halstead Metrics:**

- n1 (number of distinct operators): 6 (void, int, =, +, [], {})

- n2 (number of distinct operands): 6 (swap, x, a, tmp, 1, int)

- N1 (total occurrences of operators): 10 (void, int, =, =, +, +, [], [], {})

- N2 (total occurrences of operands): 7 (swap, x, a, tmp, x, a, 1)

Length (N) = N1 + N2 = 10 + 7 = 17
Vocabulary (n) = n1 + n2 = 6 + 6 = 12

Volume (V) = N * log2(n) = 17 * log2(12) ≈ 17 * 3.584 = 60.928

## Section-B (CO-4)

### Q.3: Attempt any SIX questions. Each question is of two marks. (2 x 6 = 12 Marks)

a) **What is the importance of Testing with respect to software?**

Testing is crucial to ensure the quality, reliability, and performance of software. It helps identify
and fix defects, ensures the software meets user requirements, prevents costly failures, and
improves the overall user experience.

b) **What is the reason that Software has Errors?**

Software errors arise from various factors including human mistakes in design and coding,
misunderstanding requirements, complexity of software systems, changes in requirements, and
integration issues between different system components.
c) **What is the SQA Plan?**

The Software Quality Assurance (SQA) Plan outlines the processes, procedures, and activities
required to ensure that software meets specified standards and requirements. It includes
methods for quality control, testing, reviews, and audits.

d) **Explain the concept of Stub and Driver.**

Stubs and Drivers are used in unit testing of software modules. A **Stub** is a dummy
component that simulates the behavior of a module a unit depends on, while a **Driver** is a
dummy module that calls the unit being tested, simulating the behavior of a module that invokes
it.

e) **Write the difference between Alpha and Beta testing.**

- **Alpha Testing**: Conducted by the developers or internal testers within the organization. It is
an internal test before the software is released to external users.
- **Beta Testing**: Conducted by real users in a real environment. It is an external test that helps
gather feedback and find defects that were not discovered during Alpha testing.

f) **What is Sandwich Testing?**

Sandwich Testing is a hybrid approach combining both top-down and bottom-up integration
testing. It involves testing in two phases: integrating and testing from the top and bottom layers
of the system towards the