ABSTRACT

This booklet contains the questions which are most

important for the purpose of BCS051 TEE

AUTHOR : Yash Kumar

For any query email at [email protected]

SOFTWARE
ENGINEERING
BCS051
 Software Engineering (BCS051)
B1U2 Function Oriented Modeling
1. What is a Data Dictionary ? What are its contents ? How is data dictionary
created? Explain with the help of an example.
Ans : Data dictionary is the repository of information about data items such as origin of data;
data structure, data usage and other metadata information related to data elements.
Data dictionaries help to organize and document the information related to data flows, data
processes and data elements in a structured fashion.
Data dictionaries contain information about following high level elements:
• Data element/item details
• Data structure and definition.
• Data process
• Data stores
For creating data dictionary we first identify the main data elements, data store, data
processes, external and internal entities. Once the high level data elements are identified,
more details such' as data structure, element details are described. Similarly all data flows and
data stores are further expanded to describe the data structure of its data elements.

AUTHOR : YASH KUMAR 1

AUTHOR : YASH KUMAR 2
 2. What is a Structure Chart ? Explain with the help of an example.
Ans : A structure chart (SC) decomposes the high level system into multiple, executable tasks.
It follows the top-down design approach and represents module hierarchy in tree structure.
Structure chart essentially describes the list of functions, sub-functions along with their
relationship that constitute a system along with data and control flow.
Next question can be used as example

AUTHOR : YASH KUMAR 3

 3. Draw structure chart for online shopping system
Ans : The structure chart for online shopping system is follows:

AUTHOR : YASH KUMAR 4

B1U3
1. List the diagrams whose specifications are supported by UML.
Ans : UML supports specifications for following diagrams
• Class diagram (Design View)
• Use case diagram (use case view)
• Sequence diagram (use case and design view)
• Collaboration diagram (use case and design view)
• Deployment diagram (deployment view)
• Object diagram (use case and design view)
• State chart diagram (design and process view)
• Activity diagram (design and process view)
• Component diagram (implementation view)

2. What is use case diagram ? Draw and define the use of any four symbols
used to draw use case diagram. Explain with the help of an example.
Ans : Use case diagram is used to show the relationship between the user and the system
and creates the boundary of the system. It is used to :
• Understand the requirements clearly.
• Enable users to understand the system.
• Generate test case to validate the system.
• Build project schedule.
Use of any four symbols :
➢ System: It shows the boundary of the system and is represented by a rectangle

➢ Actor: It represents the user or people or device which interacts with the system. It
gives input to the system. They are outside of the system boundary.

➢ Use Case: It shows the desired function of the system. It defines the requirements of
the system. Actors gives input to the use case and use case provides output for the

AUTHOR : YASH KUMAR 5

 given input.

➢ Generalization: It shows the concept of inheritance among use cases and actors. It is
represented by a line with a hollow arrowhead pointing towards the parent

Example: Here is an example for the use case diagram for the admin of a home solution
app :

3. What is class diagram ?

Ans : Class diagram shows the static view of the system by showing the classes and their
relationships. A class integrates the data and behaviour into one unit. In UML, we can
represent the class by a rectangle consisting of class name, attributes and operation.

Class specifies the visibility values which include public (+), private (-), Protected (#) and
package (similar)
Three types of relations, namely, association, aggregation and generalization can exist
between classes in the class diagram, Association relates a class A to class B and is shown as
a link between classes.

AUTHOR : YASH KUMAR 6

Generalization between two classes is shown by is-a relationship, The classes between which
Is-a relationship is identified are called superclass and subclass respectively. Subclasses
inherit the features of superclass in addition to features which are specific to subclass.

AUTHOR : YASH KUMAR 7

B2U1
1. Explain object oriented design.
Ans : Object-oriented design (OOD) in software engineering is a way of designing software by
thinking of it in terms of "objects" rather than just procedures or functions. These objects
represent real-world entities or concepts and combine both data and behavior. Here's a simple
breakdown:
1. Objects: Imagine objects as "things" or "entities" in your software that have specific
characteristics (data) and actions (behavior). For example, in a car design, a car would
be an object, with characteristics like color, model, and speed (data) and behaviors like
accelerating or braking (actions).
2. Classes: A class is like a blueprint or template for creating objects. For example, the
class "Car" would describe what a car is (its characteristics and actions), but the actual
car you drive is an "object" created from that blueprint.
3. Encapsulation: This means bundling data and the methods that operate on that data
together inside an object. It keeps the internal workings of an object hidden from other
parts of the software, allowing users to interact with the object without worrying about its
inner details.
4. Inheritance: This is a way to create new objects based on existing ones, allowing the
new objects to reuse characteristics and behaviours from the old ones. For example,
you might have a "Vehicle" class, and a "Car" class can inherit from it, getting all the
features of a vehicle but adding more car-specific behaviours.
5. Polymorphism: This allows objects to be treated as instances of their parent class, but
they can behave differently. For example, you might have a "Vehicle" class with a
"move" method, but the way a "Car" moves might be different from the way a "Bicycle"
moves.
6. Abstraction: This involves simplifying complex reality by modelling objects only with
the necessary details. For example, when designing a "Car" class, you only focus on
the key properties (e.g., speed, model) and behaviours (e.g., drive, stop), not the
intricate details of how the engine works.
In software engineering, using object-oriented design helps break down complex systems into
manageable parts, making it easier to write, understand, and maintain the code.

2. What is meant by function oriented design ? Explain the concepts

associated with function oriented design. Explain its advantages and
disadvantages.
Ans : Function-oriented design (FOD) in software engineering is an approach where the
system is designed by focusing on the functions or operations that need to be performed,
rather than on the entities (or objects) like in object-oriented design. Function oriented design
essentially deals with creating functions to convert input into the desired output.
The concepts associated with function oriented design are follows :

AUTHOR : YASH KUMAR 8

 • Function : It is a unit of code consisting of a sequence of instructions required to
perform a specific task. It is often referred to as method or routine in different
programming languages.
• Function state: It's the data on which a function operates. For example a function
getEmployeeDetail would require the employee state stored in the database. In a
function oriented design, the state is centrally stored and is accessible to all functions.
• Sub Function: The main function can be further broken down into smaller re-usable
units of code or sub-functions or sub-routines. For instance getEmployeeDetails main
function can further invoke getlimployeeContactlretails and
getEmployeePersonaLDetails
Advantages of Function-Oriented Design:
➢ Simplicity: Easier to understand and implement for simple, task-based systems.
➢ Modularity: Functions are independent, allowing modular development and easier
maintenance.
➢ Code Reusability: Functions can often be reused across the system, reducing
redundancy.
➢ Top-down Approach: The design process breaks down the problem from the highest-
level function to smaller, manageable tasks.
➢ Efficient for Small Systems: Works well for small to medium-sized projects that have
clear, well-defined functional requirements.
Disadvantages of Function-Oriented Design:
➢ Poor Data Encapsulation: Data is separated from functions, leading to less control
over how data is accessed or modified.
➢ Scalability Issues: Becomes difficult to manage and maintain as systems grow in size
and complexity.
➢ Less Reusability for Complex Systems: Functions are often too specific to be reused
in more complex or evolving systems.
➢ Rigid Structure: Difficult to adapt to changes in requirements, as the system is tightly
coupled with functional flows.
➢ No Real-world Mapping: Does not model real-world entities, which makes it harder to
understand or extend in larger, object-oriented environments.
3. Explain the five solution design principles in function oriented design.
Ans : Five solution design principles in function oriented design are :
➢ Top-down Decomposition: Start by breaking down the problem from the top level into
smaller parts.In function-oriented design, the main function is divided into smaller,
manageable sub-functions, which are modular and reusable.
➢ Divide and Conquer: Break a large problem into smaller, independent sub-
problems.Each sub-problem is solved individually, making it easier to handle. For

AUTHOR : YASH KUMAR 9

 example, in a binary search, the data is split in half, and each part is searched
separately.
➢ Hierarchical Modeling: Visualize the problem as a hierarchy, with different levels of
components. Design a function for each component, following the structure of the
hierarchy.
➢ Modular Design: Ensure each part of the system (module) is loosely connected with
minimal dependencies.This makes it easier to change or update parts of the system
without affecting others.
➢ Abstraction Modeling:Each function or module should provide a clear, complete
service without exposing unnecessary details. It should have a well-defined interface,
like a "checking account" module that handles everything related to that account.

4. What is coupling? How is it different from cohesion?

Ans : Coupling : Coupling indicates the dependencies across different modules. If, a module
is dependent on multiple functions in another module, then it is known as strong coupling;
lesser number of dependencies indicate loose coupling.
Coupling:
• Refers to the degree of dependence between different modules or components.
• Low coupling is preferred, meaning modules should be as independent from each
other as possible.
• High coupling means modules are tightly linked, making changes in one module likely
to affect others.
Cohesion:
• Refers to how closely related and focused the functions within a single module are.
• High cohesion is ideal, meaning a module performs a single, well-defined task or
responsibility.
• Low cohesion means the module does a lot of unrelated things, making it harder to
maintain or understand.
5. What is meant by cohesion ? Explain different types of cohesion.
Ans : Cohesion is the measure of how well the internal elements of amodule or a function are
connected to each other. In other words, the function should perform only a single tasks. The
logic and variables present in the function should be to perform a single activity only, in the
most optimal fashion. This enables a strong internal relationship between the internal elements
of a function.
Types of cohesion :
➢ Coincidental cohesion: In this type of cohesion, the internal functions in a given
module are loosely correlated.
➢ Communication cohesion: In this type of cohesion, the functions within the module
update the same data type.

AUTHOR : YASH KUMAR 10

 ➢ Sequential cohesion: The functions of a module are said to have sequential cohesion
if individual functions of a module form a., sequence for executing a given functionality.
For instance, the output of the first function is fed as input for the second function.
➢ Functional cohesion: This is the strongest type of cohesion wherein, all functions
within a module are designed to achieve a single functionality.

6. Briefly explain the meaning of ‘highly cohesive’ system. Is there any

relation between ‘coupling’ and ‘cohesion’? Explain briefly.
Ans : A highly cohesive system is one where each module or component focuses on a single,
well-defined task or responsibility. The functions within a module are closely related and work
together to achieve a specific purpose. This makes the system easier to understand, maintain,
and extend, since each module has a clear and singular responsibility .
• Example: A module that handles all user authentication processes (like login, logout,
and password reset) would be highly cohesive because all its functions revolve around
a single concept: user authentication.

There is an inverse relationship between coupling and cohesion:

• High Cohesion typically leads to Low Coupling:
1. When modules are highly cohesive, they are self-contained and focus on a
specific task, reducing their dependency on other modules. This naturally lowers
coupling.
• Low Cohesion can lead to High Coupling:
o If a module handles many unrelated tasks (low cohesion), it often depends on
other modules to perform its operations, leading to higher coupling.

AUTHOR : YASH KUMAR 11

B2U2
1. What is meant by static object ? How will you identify them ? Explain.
Ans : In object-oriented design, classes and their instances, objects are categorized as "static"
because they represent time-invariant view of the system. For instance, let's consider an
object Person with person Id and personName as its attributes. The values of these two
attributes would not change with time once it is instantiated. In other words, the object does
not undergo a time-dependent change.
How to Identify Static Objects:
• Noun Analysis: Look for nouns in the problem domain (e.g., Student, Book). These
typically represent static objects.
• Time-Invariant Nature: Static objects don’t change over time (e.g., the student’s ID
remains constant).
• Relevance to Use Case: Focus on core entities, ignoring irrelevant nouns (e.g., Library
Rack isn’t crucial to the book checkout process).
Example from the Scenario:
In the Book Checkout Use Case from a library system, the following objects can be identified
as static:
• Student: Represents a library member whose identity is constant over time.
• Library: Represents the institution, a structural entity.
• Book: Represents the object being issued, which maintains its attributes (like title and
author).
• Librarian: Represents the person issuing the book, whose role is consistent.
• TransactionRegistry: Captures the record of transactions, which does not change in
itself once a transaction is logged.

2. Explain the specification of a static object.

Ans : A specification essentially provides a complete definition for an object including its .
purpose, field/operation descriptions so that the user can understand and use the object as
expected.
• Purpose/Responsibilities: his would specify the main purpose or concern addressed
by the class. This is often provided as class-level and method level documentation
• Attributes: This provides details of attributes including their name, data type and
optional initial value.
• Operations: This provides details of functions including the return type, arguments.
• Constraints: This provides list of constraints of the class

3. In Object Oriented Design, list the common utility objects and criteria for
identifying utility objects.

AUTHOR : YASH KUMAR 12

Ans : Common Utility Objects : The following are the list of utility objects generally used in a
typical enterprise application:
• CachingUtility: For handling the caching requirements
• LoggingHelper: For logging info, debug and error statements
• FileReaderUtility: For reading the required files
• ResourceLocator: For providing the URL for a given resource
• BuildUtility: For handling build activities
• EncryptionUtility: For-encrypting/decrypting the values as per enterprise standards
• ExceptionHandlerUtility: For handling exceptions
• EncoderUtility: For performing HTML encoding/decoding
• StringConverterUtility: For converting string into appropriate display formats
• MultiLangUtility: Forgeting the language specific resource bundle for a given key
• ConfigurationHandler: For handling different configuration files
• ValidationUtility: For performing required field validation

4. What is an Object ? How is it different from class ? Explain use of static

objects in problem solving with the help of an example
Ans : In object-oriented programming (OOP), an object is an instance of a class that
represents a real-world entity or concept. It encapsulates both data (attributes or properties)
and behavior (methods or functions). Objects are the fundamental building blocks of an
OOP system, enabling modularity, reuse, and abstraction.
For example, in a banking system, a Customer object might have attributes like
customerName and customerID, and methods like deposit() and withdraw() to interact
with the system
How is an Object Different from a Class?
• Class: A class is a blueprint or template used to create objects. It defines the attributes
and behaviors that objects instantiated from the class will have but does not represent
actual data. For example, a class Car defines what a car is (properties like color and
model, methods like drive()), but doesn’t represent a specific car.
• Object: An object is an instance of a class, representing a specific entity with actual
data. If Car is a class, then myCar (e.g., a red Toyota) is an object of that class, with
specific values for the attributes defined in the class.
Use of Static Objects in Problem Solving
Static objects are objects that belong to the class itself rather than to any particular instance
of the class. They are shared among all instances of the class. This means that a static object
can be accessed without creating an instance of the class.
Example: Library Management System
Let’s consider a library management system where we want to keep track of the total number
of books available in the library.
Define a Class with a Static Object:

AUTHOR : YASH KUMAR 13

public class Library {
private static int totalBooks; // Static attribute

public Library() {
totalBooks = 0; // Initialize totalBooks
}

public void addBook(int number) {

totalBooks += number; // Add books to the total
}

public static int getTotalBooks() { // Static method

return totalBooks; // Return total number of books
}
}

Using the Library Class:

public class Main {
public static void main(String[] args) {
Library library1 = new Library();
library1.addBook(5); // Adding 5 books

Library library2 = new Library();

library2.addBook(10); // Adding 10 books

// Accessing static method to get total books

System.out.println("Total books in library: " + Library.getTotalBooks()); // Output: 15
}
}

5. What are application logic objects ? Explain with the help of an example.

AUTHOR : YASH KUMAR 14

Ans : Application logic objects are objects in a software system that encapsulate the core
business rules and processes, and reside in the business logic or application layer. These
objects handle the functional aspects of the system, ensuring that business rules are applied
correctly and consistently throughout the application. They interact with data access objects
(DAOs) and other layers, serving as a central place for logic execution.
The purpose of using application logic objects is to separate the business logic from other
layers, such as the presentation layer (user interface) and data access layer (database). This
separation enhances modularity, reusability, testability, and maintainability of the software.
Example of Application Logic Objects:
Let’s consider a banking system with a use case for opening an account. The business rules
are as follows:
• The user can open a savings or checking account.
• A savings account must maintain a minimum balance of 10,000 Rupees per quarter. If
not, a fine of 500 Rupees is deducted.
• Each savings account is linked to one credit card, and the credit limit is based on the
balance in the account.
• If the user fails to pay the minimum amount due on the credit card, the outstanding
amount is debited automatically from the savings account.
Based on these rules, the following application logic objects can be identified:
• Account: This object holds the logic for general account-related operations, like
opening or closing an account.
• SavingsAccount: This object contains the specific business rules for savings accounts,
such as ensuring the minimum balance and applying fines if the balance is below the
threshold.
• CurrentAccount: This object holds the logic for a current (checking) account, which
might have different rules from a savings account.
• CreditCard: This object manages credit card-related rules, such as calculating credit
limits based on account balance and automatically debiting outstanding amounts from
linked savings accounts.

AUTHOR : YASH KUMAR 15

B2U3
1. What is Testing ? Why is it needed ?
Ans : Software testing is a process of executing it (software or program) again and again with
the purpose of finding errors in it.
Software testing is also a process of examining if the software meets those stated
requirements or not.
Software testing is the process of evaluating software for its quality in terms of meeting the
requirements, accuracy and efficiency.
Need of software testing
When software is implemented, it has errors. The errors in software are usually known as
bugs. We must understand that not even a perfect and experienced developer is capable of
writing a bug free code. The main and initial purpose of software testing is to fmd out the errors
or bugs in a developing software. A program is run again and again with a purpose to find
errors in it. A program or software is run and each of its functionality is tested to verify
accuracy. While testing bugs are found and reported. The developer corrects the code that is
causing the bug and it is tested again. Hence, and testing is a cpctitive exercise to identify the
bugs and correcting them, identifying and correcting them again.
In this process of finding and correcting errors, software testing hence, assures the reliability of
software in terms of its functionality with respect to its requirement specifications.
Software testing is also required to test the performance of the system. Software of a good
quality not only works correctly but efficiently as well. Hence, the important purpose of
software testing is also to check the performance of the software. If the software is not able to
achieve its functionality efficiently (say if it is taking a lot of time) then also it needs to be
corrected. We must remember that along with functionality, time constraint to complete a task
by the software is equally important.

2. Explain the terms “Black Box Testing” and “White Box Testing”.
OR
Explain differences between white box testing and black box testing with
the help of examples for both types of testing.
Ans : White Box Testing : White box testing, also known as structural or glass box testing, is
a method of software testing that involves testing the internal structure, logic, and code of the
software. The tester has full knowledge of the source code and creates test cases based on
the internal workings of the program. The goal is to ensure that every path, decision, and
statement within the code is executed and tested for accuracy.
In white box testing, the focus is on verifying the correctness of the program's logic, not the
software's functional requirements. Test cases are designed to maximize code coverage,
ensuring that all possible branches of the program are executed. It is typically conducted by
developers and guarantees that all independent paths and logical decisions are tested
thoroughly.
Example

AUTHOR : YASH KUMAR 16

For a loop structure like
for (I = 0; I <= 10; I ++) {
}
We must test it separately for boundary values of loop variable counter i.e. 0 and 10. We must
test for within values like 1 to 9:
Black Box Testing : Black box testing, also known as functional testing, is a software testing
method that focuses on testing the application's functionality without any knowledge of its
internal code or structure. The tester only knows the input and the expected output, not how
the code produces the output. The goal is to verify whether the software meets the specified
requirements and functions correctly.
In black box testing, the tester evaluates the software based on its external behavior by writing
test cases for each requirement. It is concerned with whether the software performs the tasks
it is supposed to, such as login, viewing catalogues, placing orders, or processing payments.
This testing method ensures that the software fulfills its intended functionality without
considering the underlying code or logic.
Example
Suppose ,we are required to build software for purchasing books online. The simpler
requirements can be stated as
Requirement1- User should be able to login to the website
Requirement2- User should be able to see books catalogue
Requirement3- User should be able to place an order
Requirement4- User should be able to make the payment
Reqnirement5- User should be able to logout

3. What is Regression Testing ? What is its use in integration testing ?

Ans : whenever a new module is added we first test the functionality that may be added by the
new module. Then we must also test all the functionality or test cases of the modules that were
previously working well. This is done to ensure that any changes caused due to addition of
new module does not affect the ones that were working prior to the changed/added modules.
This is what is known as regression testing. This may be defined as, whenever any change is
made to the code or a new module is implemented and integrated, all the possible test cases
those that have been executed before are also executed again to ensure that no error entered
into the already working software.

4. Explain System Testing and Integration Testing technique briefly.

Ans : As the name suggests, System testing is the level of testing where a complete system is
tested as a whole.
In system testing, we test the system as a whole with all parts integrated together in an
operational environment. This falls in the area of black box testing. No logic or code is visible

AUTHOR : YASH KUMAR 17

at this stage when the system testing is performed. Testing is performed totally from an
operational point of view of the system.
Integration testing is the step of software testing in which different modules are integrated
and tested together. Software, as we know, is the integrated collection of all the modules. And
these modules communicate with each other. In integration testing, our focus is mainly on
testing the interfaces between the modules. In integration testing, the main purpose is to
detect problems in interfaces between modules. We test whether the arguments passed by the
calling module are exactly the parameters expected by the called module. We must test for
any parameter mismatch on both sides.

AUTHOR : YASH KUMAR 18

B2U4
1. Explain various Debugging strategies.
Ans : Effective debugging requires a good understanding of how the system works and
creative thinking. Here are some common strategies used to fix errors:
➢ Debugging by Cause Elimination:
This method is used for complex problems with multiple layers or components. You
remove or test each layer or component one by one to find which one is causing the
issue. For example, if a webpage is slow, you check each element (like data sources or
other components) to see which one is causing the problem.
➢ Combination of Test Data and Conditions:
This method is useful when there are multiple potential causes for the issue. You try
different combinations of inputs or conditions to figure out the exact set that leads to the
problem. For instance, if a function with three inputs causes an error, you change each
input to see which one is causing the issue.
➢ Memory Profiling:
This method is for memory-related problems. You use tools to check how memory is
being used while the program is running. It helps to identify which parts of the program
are using too much memory or not being cleaned up properly, which might be causing
the issue.
➢ Step-wise Debugging:
This technique is done using an Integrated Development Environment (IDE). You run
the program in “debug mode” and control each step of execution. This allows you to
inspect variables and find the exact line of code where the error occurs.
➢ Call Tracing:
This is a top-down method where you trace the function calls starting from the highest
level to the data source. By checking the return values at each step, you can find which
part of the code is causing the issue.

2. What is verification? How is it different from validation? Briefly explain any

four principles of software testing.
Ans : Verification: This is the process to ensure that software is coded as per the given
specifications. For instance, banking software should correctly implement a "Fund transfer"
transaction and satisfy all involved business rules. Here, various formal methods such as
structured testing, manual inspection will be adopted.
Validation : This process ensures whether the software meets the end-user .requirements.
For example, a validation process would check if the customer can run the banking software
on a mobile device. This would involve verification of various testing processes and
documents.
Principles of software testing :

AUTHOR : YASH KUMAR 19

 ➢ Testing shows presence of errors: The primary goal of testing is to uncover defects in
the software. Testing can show that there are defects, but it cannot prove that there are
no defects.
➢ Exhaustive testing is not possible: It is impractical to test all possible inputs,
scenarios, and paths in a software application due to the vast number of combinations.
Instead, testers focus on the most critical and likely scenarios.
➢ Test early and regularly: Testing should begin as early as possible in the software
development lifecycle and be conducted regularly. Early testing helps identify defects
sooner, reducing the cost and effort required to fix them.
➢ Accumulation of errors: Defects tend to cluster in certain areas of the software. By
identifying and focusing on these error-prone areas, testers can more effectively find
and fix defects.
➢ Fading effectiveness: The effectiveness of testing diminishes over time. As the same
tests are repeated, they become less likely to find new defects. It is important to update
and diversify test cases to maintain their effectiveness.
➢ Testing depends on context: The approach to testing should be tailored to the
specific context of the software, including its purpose, environment, and user base.
Different types of software require different testing strategies.
➢ False conclusion: no errors equals usable system: Just because no defects are
found during testing does not mean the software is usable or meets user needs.
Usability, performance, and other non-functional aspects must also be considered.

3. What is acceptance testing ? Briefly explain alpha and beta testing.

Ans : Acceptance testing : Software for a specific customer is built for one client with
specific requirements. In this case, only that customer is the end user of the test-Once the
software is ready ~it is given to the customer. The customer who is the end user of this
application tests the software against all specified requirements. This type of testing is known
as acceptance testing. This is not performed by the developer but rather by the client
himself/herself.
The purpose of acceptance testing is to find only if, the actual user is ready to accept the
software that has been developed. It depends upon the nature of the application and on the
customer and would want to perform the acceptance testing. Acceptance testing can be
informal and may take a very short time. For some applications and clients, it could be a
systematic and time consuming process.
Alpha and beta testing :
In alpha testing, a proposed customer (end user) who is ready to use the software is
identified. End user performs the testing at the developer's site itself. The software is used by
the end user, while the developer observes the process. The end user uses the software in its
natural way, and the developer focuses on noticing the way the user takes arid uses the
software. Developers focus on noticing the usability problems faced by the end user as weIl as
the errors countered.

AUTHOR : YASH KUMAR 20

In beta testing, an end user is identified who is ready to perform the testing at his site. Beta
testing is performed at the site of the end user and the developer is not present. The Software
product is treated as "live;' application by the end user and used in its natural way. Note that
the developer is not present at the moment. Hence, in beta testing, the environment in which
testing is performed is actually the simulation of the environment where the product will be
actually used. The end user tests the software and records all the errors encountered. The
recorded errors and usability problems are conveyed to the developer. Developers takes their
time to understand the errors and make necessary

AUTHOR : YASH KUMAR 21

B3U1
1. Describe the Waterfall model. Explain the nature of problems for which
Waterfall model of software development is suitable. Also briefly explain
demerits of Waterfall model.
Ans : It is the simplest, oldest and most widely used process model. In this model, each phase
of the life cycle is completed before the start of a new phase. It is actually the first engineering
approach of software development. The waterfall model provides a systematic and sequential
approach to software development and is better than the build and fix approach.

Nature of Problems Suitable for the Waterfall Model

➢ Stable Requirements: The Waterfall model works best for projects where the
requirements are clearly defined, stable, and unlikely to change during development.
This is common in projects where stakeholders know exactly what they need from the
start, such as government, military, or industrial systems.
➢ Well-Understood Technology: It is suited to projects where the technology is mature
and familiar, minimizing the risk of unexpected technical challenges. Established
systems, like embedded or legacy systems, benefit from this approach.
➢ Fixed Scope and Timeline: The Waterfall model is ideal for projects with a fixed scope,
budget, and strict deadlines. It works well when the entire project can be planned out in
detail from the start, without needing adjustments or flexibility, like in certain
construction or legal compliance projects.
➢ Documentation-Heavy Projects: Projects requiring detailed documentation for
regulatory or maintenance purposes also suit the Waterfall model since each phase
produces comprehensive documentation before moving forward.
Demerits of the Waterfall Model

AUTHOR : YASH KUMAR 22

 ➢ Lack of Flexibility: One of the main drawbacks is its rigidity. Once a phase is
completed, it is difficult and costly to go back and make changes. This makes it
unsuitable for projects where requirements might evolve or change over time.
➢ Late Testing and Feedback: Testing only occurs after the development phase,
meaning bugs and issues might not be discovered until later stages, leading to higher
costs for fixing them and potential delays in delivery.
➢ Poor Adaptability to Changing Requirements: If the client’s needs change during
development, the Waterfall model struggles to accommodate these adjustments without
significant redesigns, making it less suitable for dynamic, fast-evolving environments
like modern web or mobile app development.
➢ Delayed User Involvement: User feedback is typically gathered only after the system
is fully developed, which increases the risk of building a product that does not fully meet
user expectations or business needs.

2. Explain Spiral Model with the help of an example. What are its advantages
and disadvantages over Waterfall Model?
Ans : Spiral Model
The Spiral Model combines iterative development (prototyping) with the systematic aspects of
the Waterfall Model. It is structured around repeated cycles (spirals) of development, where
each spiral consists of four phases: Planning, Risk Analysis, Engineering, and Evaluation.
Example: Consider a software project to develop a complex online banking system. The
development would proceed as follows:
1. Planning: Define the scope and requirements of the banking system, such as user
authentication, transaction processing, and account management.
2. Risk Analysis: Identify potential risks, such as security vulnerabilities, integration
issues with third-party services, and compliance with regulations.
3. Engineering: Develop a prototype of the user authentication feature, incorporating user
feedback and addressing identified risks.
4. Evaluation: Present the prototype to stakeholders for feedback and make necessary
adjustments. Once approved, move on to the next feature, such as transaction
processing, repeating the spiral process.
This cycle continues until the entire system is developed, allowing for continuous refinement
and risk mitigation.
Advantages of the Spiral Model over the Waterfall Model
Risk Management:
➢ The Spiral Model emphasizes risk assessment and mitigation at each phase,
reducing the likelihood of encountering critical issues later.

AUTHOR : YASH KUMAR 23

 ➢ The Waterfall Model lacks a structured approach to managing risks, leading to
potential problems being discovered only in later stages.
User Feedback:
➢ Frequent iterations in the Spiral Model allow for continuous user feedback,
ensuring that the product aligns with user expectations and requirements.
➢ In the Waterfall Model, user feedback is typically gathered only at the end of the
project, which can lead to misalignment with user needs.
Flexibility and Adaptability:
➢ The Spiral Model is inherently flexible, allowing changes in requirements and
design to be easily incorporated during the development process.
➢ The Waterfall Model is rigid, making it challenging to implement changes once a
phase is completed.
Incremental Development:
➢ The Spiral Model supports incremental development, allowing teams to deliver
working software in phases, which can be beneficial for project stakeholders.
➢ The Waterfall Model delivers the entire product only at the end, which can delay
user access to functional features.
Focus on Project Management:
➢ The Spiral Model places a strong emphasis on project management and control,
ensuring that all aspects of the project are monitored throughout the
development process.
➢ The Waterfall Model is less focused on ongoing project management, which can
lead to issues being overlooked until they become critical.
Disadvantages of the Spiral Model compared to the Waterfall Model
Complexity:
➢ The Spiral Model can be complex to manage due to its iterative nature and the
need for thorough risk analysis at each stage.
➢ The Waterfall Model is more straightforward, making it easier to understand and
manage for teams with less experience.
Higher Costs:
➢ The iterative approach of the Spiral Model can lead to increased costs due to
ongoing development, risk assessments, and user feedback sessions.
➢ The Waterfall Model can be more cost-effective for projects with well-defined
requirements and less need for iteration.

AUTHOR : YASH KUMAR 24

 3. Explain Iterative Enhancement Model with the help of an example. What are
its advantages and disadvantages over Spiral Model ?
Ans : Iterative Enhancement Model
The Iterative Enhancement Model, also known as the Iterative Model, is a development
approach that focuses on building a system incrementally. It allows for the refinement of
requirements and design through repeated iterations or enhancements of the software. Each
iteration involves planning, designing, implementing, and testing a portion of the system,
followed by feedback and further improvements.
Example: Consider a project to develop a content management system (CMS) for a website.
The development process could be structured as follows:
Initial Requirements: Gather basic requirements for essential features like user
registration, content creation, and a simple admin interface.
First Iteration:
➢ Planning: Define the scope for the first iteration, focusing on user registration
and content creation.
➢ Design: Create a design for these features.
➢ Implementation: Develop and test the user registration and content creation
functionalities.
➢ Review: Present the features to stakeholders for feedback.
Subsequent Iterations:
➢ Based on feedback, the team refines existing features and adds new
functionalities (e.g., admin dashboard, commenting system) in additional
iterations.
➢ Each cycle builds upon the previous work, leading to a more refined and
complete product over time.
This approach allows the project team to adapt to changing requirements and continuously
improve the software based on user feedback.
Advantages of the Iterative Enhancement Model over the Waterfall Model
User Involvement:
➢ The Iterative Enhancement Model encourages regular user feedback and
involvement throughout the development process, ensuring that the product
aligns with user expectations.
➢ In the Waterfall Model, user involvement is limited to the requirements phase,
which can lead to a mismatch between user needs and the final product.
Flexibility in Requirements:
➢ This model allows for changes in requirements at any stage of development,
accommodating evolving user needs and market demands.

AUTHOR : YASH KUMAR 25

 ➢ The Waterfall Model is rigid, making it difficult to accommodate changes once the
project is underway.
Early Detection of Issues:
➢ Frequent iterations facilitate early detection and resolution of issues, improving
overall software quality and reducing the risk of major failures.
➢ The Waterfall Model often leads to late-stage discovery of critical issues, which
can be costly and time-consuming to address.
Incremental Delivery:
➢ The Iterative Enhancement Model supports incremental delivery of
functionalities, allowing users to access and utilize parts of the system sooner.
➢ The Waterfall Model typically delivers the complete system only at the end,
delaying user access to functional features.
Reduced Development Risk:
➢ By addressing small portions of the project at a time and continuously iterating,
the Iterative Enhancement Model reduces overall development risk.
➢ In the Waterfall Model, the sequential nature may expose the project to higher
risk if initial assumptions prove incorrect.
Disadvantages of the Iterative Enhancement Model compared to the Waterfall Model
Project Management Complexity:
➢ The iterative nature can complicate project management, requiring careful
tracking of progress, iterations, and user feedback.
➢ The Waterfall Model is simpler to manage due to its linear and structured
approach.
Potential for Scope Creep:
➢ The flexibility to change requirements can lead to scope creep, where the project
expands beyond its original intent, potentially affecting timelines and budgets.
➢ The Waterfall Model, with its strict adherence to initial requirements, is less
susceptible to scope creep, ensuring the project remains focused.

4. Explain Prototype Model, with the help of an example. What are its
advantages and disadvantages over Waterfall Model ?
Ans : Prototyping Mode : In this model, a working model of actual software is developed
initially. The prototype is just like a simple software having lesser functional capabilities and
low reliability and it does not undergo through the rigorous testing phase. Developing a
working prototype in the first phase overcomes the disadvantage of the waterfall model where
the repotting about serious errors is possible only after completion of software development.
The working prototype is given to the customer for operation. The customer, after its use, gives

AUTHOR : YASH KUMAR 26

the feedback. Analysing the feedback-given-by the customer, the developer refines, adds the
requirements and prepares the final specification document. Once the prototype becomes
operational, the actual product is developed using the normal waterfall model.

Early Feedback and User Involvement:

➢ In the Prototype Model, users can interact with the initial versions of the system,
providing feedback early in the development process.
➢ The Waterfall Model, however, gathers requirements upfront, limiting user
feedback until the final stages, which can lead to mismatches between user
expectations and the final product.
Risk Reduction:
➢ Prototyping allows developers to identify and address potential risks, technical
issues, or design flaws early.
➢ Waterfall Model only tests for issues at the later testing stage, making it harder to
correct foundational problems without significant redesign.
Improved Requirements Understanding:
➢ Since users see a working model early on, the Prototype Model helps clarify and
solidify requirements more accurately.
➢ The Waterfall Model requires detailed initial requirements, which may be
misunderstood or incomplete, leading to potential rework.
Flexibility in Design:
➢ The Prototype Model is iterative, allowing modifications based on feedback,
making it suitable for projects where requirements are uncertain or likely to
evolve.
➢ The Waterfall Model follows a sequential approach with little flexibility, making
changes difficult once a phase is completed.
User Satisfaction:
➢ By involving users throughout development and letting them see a tangible
product, the Prototype Model often results in higher user satisfaction.
➢ The Waterfall Model has limited user interaction, which can lead to misalignment
with user needs and lower satisfaction.
Disadvantages of the Prototype Model compared to the Waterfall Model
Increased Cost and Development Time:

AUTHOR : YASH KUMAR 27

 ➢ Iterative prototyping can increase costs and extend development time as multiple
versions may need to be created.
➢ Waterfall is generally more time-efficient and cost-effective, especially for
projects with well-defined requirements.
Incomplete or Misleading Prototypes:

➢ Prototypes may only represent parts of the functionality and may create unrealistic
expectations if users perceive them as near-final products.
➢ Waterfall Model provides a complete, structured development cycle, reducing the
risk of users expecting incomplete features or shortcuts in the final product

5. Which software development model is suitable for developing ‘Online

Examination System’? Justify your selection. Also explain the selected
model.
Ans : The Spiral Model is the most suitable software development model for developing an
Online Examination System. This choice is justified due to several key characteristics of the
Spiral Model that align well with the complexities and requirements of such a system.
Justification for Choosing the Spiral Model
Complex Requirements:
➢ An Online Examination System has diverse requirements, including user
authentication, exam scheduling, question bank management, real-time result
processing, and security measures against cheating. The Spiral Model’s iterative
approach allows for detailed exploration and refinement of these complex
requirements over multiple cycles.
Risk Management:
➢ Developing an Online Examination System involves risks related to security (e.g.,
preventing cheating), data integrity, and user privacy. The Spiral Model focuses
on risk assessment and management at each iteration, allowing developers to
identify and mitigate risks early in the process.
User Feedback:
➢ Regular user feedback is crucial for an Online Examination System to ensure
that it meets the needs of students, educators, and administrators. The Spiral
Model incorporates user reviews after each iteration, facilitating adjustments
based on real user input.
Incremental Development:
➢ The Spiral Model allows for incremental delivery of features. This is beneficial for
an Online Examination System as it can start with essential functionalities (like
user login and basic exam creation) and gradually add more advanced features
(like analytics, performance tracking, and multimedia questions).

AUTHOR : YASH KUMAR 28

 Flexibility:
➢ Given the potential for changing requirements based on user feedback or
evolving educational standards, the Spiral Model’s flexibility allows for
modifications at any stage of development, accommodating changes without
extensive rework.
Explanation of spiral model is above

6. What is Capability Maturity Model (CMM) ? Briefly explain the five levels of
maturity in CMM
Ans : Capability Maturity Model (CMM)
The Capability Maturity Model (CMM) is a framework created by the Software Engineering
Institute (SEI) to help software development organizations improve their processes. It focuses
on how mature and capable an organization is in managing software development. CMM
provides a structured path for organizations to enhance their software quality and overall
process effectiveness.
Five Levels of Maturity in CMM
1. Level 1: Initial :Description: At this level, software development is chaotic and
unstructured. There are no formal processes in place, so the success of projects
depends largely on the skills of individual team members. Projects are often
unpredictable, making it difficult to manage costs and timelines.
2. Level 2: Repeatable : Description: Organizations start to establish basic project
management practices. They learn from past projects and apply successful methods to
future ones. While processes are still developing, there is more discipline in managing
projects compared to Level 1.
3. Level 3: Defined : At this stage, organizations have well-defined and documented
processes for software development. Everyone follows the same practices, and training
is provided to ensure that all team members understand and can follow the established
processes.
4. Level 4: Managed : Description: Organizations begin to measure and control their
processes quantitatively. They set specific standards for performance and collect data
to analyze how well projects are being managed. This helps them ensure quality and
consistency in their software products.
5. Level 5: Optimizing : Description: At this highest level, organizations focus on
continuously improving their processes. They actively seek feedback to identify areas
for enhancement and make changes to prevent errors. The goal is to innovate and
adopt new technologies that can improve efficiency and quality.

7. What are software metrics? Briefly explain the following software metrics:
(i) Object Oriented Metrics
(ii) Software Quality Metrics
AUTHOR : YASH KUMAR 29
Ans :

AUTHOR : YASH KUMAR 30

B3U2
1. Write short notes on the following :
(i) PERT chart
(ii) Project Planning
Ans : Program Evaluation and Review Technique (PERT) is a scheduling method originally
designed to plan a manufacturing project by employing a network of interrelated activities. Co-
ordinating, optimum cost and time criteria. PERT emphasizes the relationship between the
time each activity takes, the costs associated with each phase, and the resulting time and cost
for the anticipated completion of the entire project.
PERT is an integrated project management system. These systems were designed to manage
the complexities of major manufacturing projects, the extensive data necessary for such
industrial efforts, and the time lines created by defence industry projects. Most of these
management systems are developed following World War IT, and each has its advantages and
disadvantages.
A project plan should be based on the project requirements and developed estimates, and is a
formal, consistent and approved document that provides for the essential project guidelines.
Generally, the purpose of the document is to support management and control of the project
execution. The plan should cover all phases of the project and should ensure that all involved
plans are consistent with each other; There is no single reason for a software engineering
project to have a project plan. A project plan usually contains several parts produced in order
to help the project team with their project. The main objectives with a project plan are the
following:
• Guide project execution.
• Document project planning assumption.
• Document project planning decisions regarding alternatives chosen.
• Facilitate communication among stakeholders,
• Define key management reviews as to content, extent, and timing, and
• Provide a baseline for progress measurement and project control.
The project plan is generally developed in the initial phase of the project and needs to be
reviewed and agreed upon by all concerned persons. However, the plan is expected to change
over time and is updated each time the actual progress differs from the plan or when project
conditions change which may require new approaches. A carefully prepared project plan, if
properly followed and committed to, should lead to a successful project and eliminate many of
the pitfalls inherent in the project management process. It provides leadership vision and
facilitates for management to utilize available resources efficiently.
2. What is Software Project Management ? Explain various tasks involved in it.
Ans : Software Project Management is an Art. It is "the process of planning, organizing,
staffing, monitoring, controlling and leading a software project". Another definition for SPM
(Software Project Management) is "the application of knowledge, skills, tools, and techniques
to project activities to meet project requirements".

AUTHOR : YASH KUMAR 31

Software development is a complex process involving such activities as domain analysis,
requirements specification, communication with the customers and end-users, designing and
producing different artifacts, adopting new paradigms and technologies, evaluating and testing
software products, installing and maintaining the application at the end-user's site, providing
customer support, organizing end-user training, visualizing potential upgrades and negotiating
about them with the customers, and many more.
3. Briefly, explain ‘Step-Wise” framework.
Ans : Overview of the 'Step Wise' Framework
Step 0: Select the Project
➢ Choose a suitable project to address the organization's needs and strategic goals.
Step 1: Define Project Scope and Objectives
➢ Identify objectives and success metrics: What are we aiming to achieve? How will
we measure success?
➢ Establish project authority: Who has the overall responsibility for the project?
➢ Identify stakeholders: Who will be affected by the project, and who needs to be
involved?
➢ Refine objectives based on stakeholder analysis: Do we need to adjust our
objectives to secure stakeholder commitment?
➢ Set up communication channels: How will we keep all stakeholders informed and
engaged?
Step 2: Build Project Infrastructure
➢ Align project with strategic goals: Why does this project matter to the organization?
➢ Define standards and procedures: What standards or guidelines must we follow?
➢ Organize the project team: What is the team structure, and how will roles be
distributed?
Step 3: Analyze Project Characteristics
➢ Define project focus: Is this an objective-based or product-based project?
➢ Assess unique characteristics: What makes this project distinct?
➢ Identify risks: What potential risks could impact the project?
➢ Consider user requirements: What are the users’ expectations regarding
implementation?
➢ Select a development methodology: Should we use incremental, prototyping, or
waterfall approaches?
➢ Review resource estimates: Do our initial cost estimates need adjusting based on new
information?
Step 4: Identify Project Deliverables and Activities

AUTHOR : YASH KUMAR 32

 ➢ List project deliverables: What products must be created, and what are the quality
criteria?
➢ Create a product flow: In what sequence will we deliver these products?
➢ Identify specific product instances: Can we identify individual cases or modules that
need to be developed?
➢ Develop an activity network: What is the ideal workflow?
➢ Adjust the activity network: Incorporate stages and checkpoints for quality control.
Step 5: Estimate Effort for Each Activity
➢ Estimate effort: How long will each task take?
➢ Revise plan for manageable tasks: Break down activities into controllable units.
➢ Assess activity-based risks: What risks are associated with each task?
Step 6: Manage Activity Risks
➢ Identify potential issues: What could go wrong with specific activities?
➢ Plan risk mitigation: How can we prevent problems, and what are our contingency
plans?
➢ Adjust plans for risks: Revise estimates and schedules to account for identified risks.
Step 7: Allocate Resources
➢ Assign resources: What resources are required for each activity?
➢ Adjust plans for resource constraints: Are resources available when needed? How
do resource limitations affect the schedule?
Step 8: Review and Share the Plan
➢ Evaluate the quality aspects of the plan: Does the plan meet quality benchmarks?
➢ Complete project documentation: Ensure all documentation is thorough and up to
date.
➢ Publicize the plan: Share the plan with stakeholders and secure their agreement.
Step 9: Execute the Plan
➢ Carry out the project: Implement the plan and monitor progress closely.
Step 10: Plan at Lower Levels
➢ Reiterate the planning process: Break down tasks at a more detailed level if
necessary, ensuring continuous alignment with the overall project plan.

AUTHOR : YASH KUMAR 33

B3U3
1. Briefly explain cost of software quality.
Ans : Cost of quality includes all costs incurred in the pursuit of quality or in performing quality
related activities. The basis of normalization is almost always dollars. Once we / have
normalized quality costs on a dollar basis, we have the necessary data to evaluate where the
opportunities 1ie to improve our processes. Furthermore, we can evaluate the affect of
changes in dollar-based terms. Quality costs may be divided into costs associated with
prevention, appraisal. and failure.
Prevention costs include:
➢ Quality planning
➢ Formal technical reviews
➢ Test equipment
➢ Training
Appraisal costs include activities to gain insight into product condition "first time
through" each process. Examples of appraisal costs include:
➢ In-process and inter process inspection
➢ Equipment calibration and maintenance
➢ Testing
Failure costs are costs that would disappear if no defects appeared before shipping a product
to customers. Failure costs may be subdivided into internal failure costs and external failure
costs.
Internal failure costs are the expenses incurred when errors or defects in a product are
detected before it is shipped. These costs include:
• Rework
• Repair
• Failure mode analysis
External failure costs, on the other hand, arise from defects discovered after the product has
been delivered to the customer. Examples of external failure costs include:
• Complaint resolution
• Product returns and replacements
• Warranty repairs
• Help line support

2. What is the need of software maintenance ? Briefly explain different types of

software maintenance.
Ans : software maintenance is the process of modifying a software system or component after
delivery to correct faults, improve performances or other attributes, or adapt to a changed
environment.

AUTHOR : YASH KUMAR 34

Need for Software Maintenance: Maintenance is needed to ensure that the system continues
to satisfy user requirements. The need for Software maintenance arises due to corrective and
non corrective software actions. Maintenance must be performed due to some of the following
reasons:
➢ Hardware Obsolescence: The rate of hardware obsolescence in comparison to the
immortal software creates a demand of the user community to _seethe existing
software products run on newer platforms, in newer environments, and/or with
enhanced features.
➢ Hardware Evolution: As changes are introduced in the hardware platform, a software
product performing some low-level functions require maintenance.
➢ Environmental Changes: Changes in the support environment of a software product,
require rework in the software to cope up with the newer interface.
➢ Correct Errors: As the software is modified, maintenance is required to make the
software error free.
➢ Enhance Features: Enhancements requested in the software by the customer from
time to time require an ongoing maintenance activity.
➢ Software Portability: Ensuring portability of software across platforms, both existing
and upcoming require maintenance.
➢ Correct Requirements and Design Flaws: The ever changing requirements of the
customer during the development process and even after implementation need to be
handled as maintenance effort.
➢ Interface with other systems: Convert programs so that different hardware, software,
system features, and telecommunications facilities can be used.
➢ Migrate legacy systems.
Types for Software Maintenance: The categories of maintenance defined by ISOIIEC are as
follows:
➢ Corrective maintenance: Reactive modification-of a software product performed after
delivery to correct discovered problems.
➢ Adaptive maintenance: Modification of a software product performed after delivery to
keep a software product usable in a changed or-changing environment.
➢ Perfective maintenance: Modification of a software product after delivery to improve
performance or maintain ability.
➢ Preventive maintenance: Modification of a software product after delivery. to detect
and correct latent faults in the software product before they become effective faults.
➢ Enhancive maintenance: Modifications to the software after delivery to satisfy the
customer expectations of extended functionalities and features to support other
additional applications

3. What is Software Configuration Management (SCM) ? Briefly explain the process

of software configuration management. Explain the need of SCM with the help of
an example.
Ans : A primary goal of software engineering is to improve the ease with which changes can
be made to software. Configuration management (CM) is the discipline of controlling the
evolution of complex systems: software configuration management (SCM) is its specialization

AUTHOR : YASH KUMAR 35

for computer programs and associated documents. Software configuration management of
controlling the evolution of complex software systems.
A Software Configuration Management (SCM) Plan defines the strategy to be used for change
management. A slightly more formal definition of software configuration management can be:
SCM is a software-engineering discipline comprising the tools and techniques (processes or
methodology) that a company uses to manage change to its software assets.
SCM activities are developed to (1) identify change (2) control change, (3) ensure that change
is being properly implemented and (4) report change to others who may have an interest.
Need of SCM : Software Configuration Management (SCM) is essential for managing
changes, ensuring consistency, and maintaining control over software deliverables. Let's break
down the need for SCM with an example based on the issues mentioned in the paragraph.
Example: Consider a team of software engineers working on a large project, such as a web
application. The project consists of multiple modules, and each engineer is responsible for
developing and modifying different parts of the codebase. Without SCM, the team would face
several challenges, including:
1. Inconsistency Problem:
Each engineer might keep their own local copy of the source code. If Engineer A makes
a change to their local copy of Module A but fails to communicate it to the other
engineers, the rest of the team might not update their versions accordingly. This
inconsistency would lead to integration issues, with different parts of the software failing
to work together.
For example, if Engineer A changes the interface of Module A, but Engineer B continues to
work on Module B without being aware of this change, the two modules may no longer be
compatible when integrated. This can lead to failures during integration or testing, potentially
derailing the project.
➢ Concurrent Access:
Multiple engineers may need to access and modify the same part of the software at the
same time. Without proper SCM in place, Engineer B's changes to Module A might
unintentionally overwrite Engineer A's changes, resulting in a loss of important updates
or the introduction of bugs.
For example, if two engineers modify the same function in Module A at the same time, one
of them may unknowingly overwrite the other's work, leading to a flawed final product.
➢ Stable Development Environment:
A stable environment is crucial during integration and testing. If Engineer C keeps
changing Module C while Engineer D is trying to integrate it with Module A, this constant
flux makes it difficult to proceed. SCM helps by freezing the configuration, establishing a
stable baseline that all engineers can rely on.
For example, if Engineer D is testing how Module A interacts with Module C, and Engineer
C keeps making changes to Module C, it would force Engineer D to repeatedly restart the
testing process. By freezing Module C under SCM, the team can ensure that no
unexpected changes interfere with the testing process.

AUTHOR : YASH KUMAR 36

 ➢ System Accounting and Status Information:
SCM keeps track of who made changes and when, providing accountability and
traceability. This is important for understanding the development history and for
debugging issues when they arise.
For example, if a bug is introduced after a recent change to the code, SCM can help
identify which engineer made the change, when it was made, and what exactly was
modified, making it easier to resolve the issue.
➢ Handling Variants:
When dealing with multiple versions of the software (such as different releases or
updates), SCM ensures that any bug fixes or enhancements are consistently applied
across all versions. Without SCM, engineers would need to manually apply fixes to
each version, increasing the risk of errors.
For example, if a bug is found in one variant of the software, the team needs to fix it in all
versions. SCM helps automate this process, ensuring that the bug fix is applied uniformly
across all variants, saving time and reducing the chances of missing a version.

4. How will you ensure that the software developed by you meets the Quality
benchmarks? Define the term “Software Quality”.
Ans : To ensure that the software developed meets quality benchmarks, it's essential to follow
a structured approach that includes planning, continuous monitoring, and evaluation at every
stage of the development lifecycle. Here’s how you can ensure the software meets quality
standards:
Steps to Ensure Software Quality:
Requirements Gathering and Clear Specifications:
➢ Ensure that the requirements are well-documented, unambiguous, and clear. This is
crucial because the quality of software depends largely on how well it meets user
needs and expectations.
Adopt a Software Quality Assurance (SQA) Plan:
➢ Develop an SQA plan that includes the goals, standards, and processes to be
followed during development. This ensures that quality is integrated from the start
and is a part of every phase, from design to deployment.
Implement Design Reviews and Code Inspections:
➢ Conduct design and code reviews regularly to identify potential issues early. Peer
reviews, inspections, and walkthroughs help catch design flaws, coding errors, and
potential bottlenecks before the product is implemented.
Follow Coding Standards and Best Practices:
➢ Use standardized coding practices and conventions to ensure that code is readable,
maintainable, and consistent. This reduces errors, ensures uniformity, and improves
long-term maintainability.

AUTHOR : YASH KUMAR 37

 Use Automated Testing Tools:
➢ Implement unit testing, integration testing, and regression testing using automated
tools. These tests ensure that individual components, as well as the entire system,
work as intended.
Perform Regular Manual Testing:
➢ In addition to automated tests, conduct manual testing for user interface elements,
usability, and exploratory testing. This helps in identifying issues that automation
might miss, especially in terms of user experience and interaction.
Continuous Integration and Continuous Delivery (CI/CD):
➢ Adopt CI/CD practices to ensure that code is frequently integrated, tested, and
deployed. This allows for early detection of bugs and ensures that quality is
maintained throughout the development process.
Performance and Security Testing:
➢ Conduct performance testing to ensure that the software meets the performance
benchmarks like speed, scalability, and responsiveness. Security testing is equally
important to identify vulnerabilities and ensure that the software is protected against
threats.
Use Quality Metrics:
➢ Measure quality using well-defined metrics, such as defect density (number of
defects per KLOC), code coverage (percentage of code tested), and user
satisfaction (measured through surveys). These metrics help in evaluating the
software’s quality objectively.
User Acceptance Testing (UAT):
➢ Involve the end-users in testing the final product to ensure that it meets the user's
needs and expectations. UAT helps in validating that the product is ready for
deployment in the actual business environment.
11. Post-Release Maintenance and Monitoring:
➢ Even after the software is deployed, continue monitoring its performance and
conduct regular maintenance. Bug fixes, updates, and performance improvements
ensure the software remains reliable and of high quality.

5. Explain the process of calculating cost of a project using COCOMO model

Ans : The COCOMO (COnstructive COst MOdel) model, developed by Barry Boehm, is used to
estimate the cost, effort, and schedule of a software project based on the size of the project in terms of
lines of code (LOC). To calculate the cost of a project using the COCOMO model, the process involves
several steps:

1. Determine the Size of the Project (KLOC):

AUTHOR : YASH KUMAR 38

 • First, estimate the size of the software product in Kilo Lines of Code (KLOC), where 1
KLOC equals 1,000 lines of code. This includes any newly added, modified, or deleted
lines of code during development.
2. Choose the Mode of the Project:
The COCOMO model has three modes:
• Organic: For small, simple projects with small teams.
• Semi-detached: For medium-sized projects with moderate complexity.
• Embedded: For large, complex projects with tight constraints.
Based on the mode, different effort multipliers and parameters are used to calculate the cost.
3. Apply the COCOMO Effort Equation:
The effort EEE is calculated using the formula:
E=a×(KLOC)bE = a \times \text{(KLOC)}^bE=a×(KLOC)b
where:
• aaa and bbb are constants that vary depending on the mode of the project.
• KLOC\text{KLOC}KLOC is the size of the project in Kilo Lines of Code.
For example:
• Organic mode: E=2.4×(KLOC)1.05E = 2.4 \times
(\text{KLOC})^{1.05}E=2.4×(KLOC)1.05
• Semi-detached mode: E=3.0×(KLOC)1.12E = 3.0 \times
(\text{KLOC})^{1.12}E=3.0×(KLOC)1.12
• Embedded mode: E=3.6×(KLOC)1.20E = 3.6 \times
(\text{KLOC})^{1.20}E=3.6×(KLOC)1.20
This effort is typically measured in person-months (PM).
4. Estimate the Development Time:
The development time TTT can be estimated using the formula:
T=c×EdT = c \times E^dT=c×Ed
where:
• ccc and ddd are constants depending on the project mode.
• EEE is the effort (from the previous step).
For example:
• Organic mode: T=2.5×E0.38T = 2.5 \times E^{0.38}T=2.5×E0.38
• Semi-detached mode: T=2.5×E0.35T = 2.5 \times E^{0.35}T=2.5×E0.35
• Embedded mode: T=2.5×E0.32T = 2.5 \times E^{0.32}T=2.5×E0.32

AUTHOR : YASH KUMAR 39

The development time is typically measured in months.
5. Calculate the Development Cost:
The total development cost is computed by multiplying the total effort EEE by the cost per
person-month (usually based on the salary of engineers). For example:
Development Cost=E×Cost per person-month\text{Development Cost} = E \times \text{Cost
per person-month}Development Cost=E×Cost per person-month
6. Estimate Maintenance Cost Using Annual Change Traffic (ACT):
• Boehm introduced the concept of Annual Change Traffic (ACT), which measures the
fraction of the software that undergoes change in a year (i.e., added or deleted code).
• The formula for ACT is: ACT=KLOC added+KLOC deletedKLOC totalACT =
\frac{\text{KLOC added} + \text{KLOC deleted}}{\text{KLOC
total}}ACT=KLOC totalKLOC added+KLOC deleted
• The maintenance cost is calculated by multiplying the ACT by the development cost:
Maintenance Cost=ACT×Development Cost\text{Maintenance Cost} = ACT \times
\text{Development Cost}Maintenance Cost=ACT×Development Cost
This formula considers the ongoing changes in the software and their impact on maintenance
costs.

AUTHOR : YASH KUMAR 40

Online Shopping System
1. What is SRS ? Explain properties of good SRS. Develop SRS for an ‘online shopping
system.’ Make necessary assumptions using IEEE SRS format.
2. Draw use case diagram for ‘Online Shopping System.
3. Draw first two levels of DFDs for ‘Online Shopping System’. Make necessary
assumptions.
4. Draw PERT chart for the development of ‘Online Shopping System.
5. Draw a Gantt chart for the development of an ‘Online Shopping System’.
6. Draw a class diagram for ‘Online Shopping System’.

Online Admission System (OAS)

1. Develop SRS for Online Admission System (OAS) for a university. SRS should be in
IEEE format. assumptions.
2. Draw the zero and first level DFDs for OAS. Make necessary assumptions.
3. Draw PERT chart for the development of OAS.
4. Draw ERD for OAS. Make necessary assumptions.
5. Draw use case diagram for OAS.
6. Draw a class diagram for OAS.

Online Examination Form Submission System (OEFSS)

1. Develop SRS for Online Examination Form Submission System (OEFSS). SRS should
be in IEEE format. Make necessary assumptions.
2. Draw the zero and first level DFDs for OEFSS. Make necessary assumptions.
3. Draw GANTT Chart for the development of OEFSS.
4. Draw PERT chart for the development of OEFSS.
5. Draw ERD for OEFSS. Make necessary assumptions.
6. Draw a class diagram for OEFSS.

AUTHOR : YASH KUMAR 41