01. Who is considered the father of Software Engineering?

02. Which model is also known as the classic life cycle model?
03. The main drawback of the Waterfall model is:
04. Which model combines iterative and incremental development?
05. What is the primary role of a project manager?
06. What does COCOMO stand for?
07. Risk management involves
08. Which document outlines software requirements?
09. Which of the following improves cohesion?
10. High coupling in a system is:
11. Which design approach uses Data Flow Diagrams?
12. A good design should have:
13. UML stands for:
14. Which UML diagram shows interactions between users and the system?
15. Which design pattern deals with object creation?
16. OOD stands for:
17. What is the first step in GUI development?
18. Black-box testing is based on:
19. White-box testing is also called:
20. Which is not a GUI component?
21. Which standard relates to software quality?
22. Which model supports continuous quality improvement?
23. Reverse engineering is done for:
24. System testing is done after:
25. Program analysis tools are used during:
26. Which model is most suitable for high-risk projects?
27. Which estimation technique is algorithmic?
28. DFD stands for:
29. A class diagram in UML shows:
30. Unit testing focuses on:

Short questions:-
01. Define Software Engineering.

Ans:- Software Engineering is the systematic application of engineering principles to the design,
development, testing, deployment, and maintenance of software systems.

It involves using structured processes and methodologies to:

 Understand user requirements

 Design efficient and scalable solutions
 Implement clean and maintainable code

02. List two advantages of the Spiral model.

Ans:- Here are two advantages of the Spiral model:

1. Risk Management:
The Spiral model emphasizes early identification and mitigation of risks at every phase, making it
especially suitable for complex and high-risk projects.
2. Flexibility in Requirements:
It allows for changes in requirements at different stages, which is helpful when requirements are
unclear or likely to evolve during the development process.
 03. What is project planning in software project management?

Ans:- Project planning in software project management is the process of defining the scope, objectives,
tasks, resources, timelines, and budget necessary to successfully complete a software project.

It involves creating a detailed roadmap that guides the development team and stakeholders throughout the
project lifecycle.

Key components of project planning include:

 Defining project scope and goals

 Identifying tasks and deliverables
 Estimating time and effort

04. Mention any two risk management techniques.

Ans:- Here are two risk management techniques used in software project management:

1. Risk Identification:
This involves systematically identifying potential risks that could affect the project, such as technical
challenges, resource limitations, or changing requirements.
2. Risk Mitigation:
This technique focuses on developing strategies to reduce the impact or likelihood of identified risks,
such as creating backup plans, using proven technologies, or allocating extra resources for high-risk
tasks.

05. What is the purpose of a Software Requirements Specification (SRS)?

Ans:- The purpose of a Software Requirements Specification (SRS) is to provide a clear, complete, and
detailed description of the software system's requirements.

It serves as a formal agreement between stakeholders (such as clients, users, and developers) and typically
includes:

 Functional requirements (what the software should do)

 Non-functional requirements (performance, security, usability, etc.)
 Constraints (technical, regulatory, or business limitations)
 Interfaces and interactions with other systems

06. Differentiate between cohesion and coupling.

Ans:- Here is the difference between cohesion and coupling in software engineering:

Aspect Cohesion Coupling

Degree to which elements within a module
Definition Degree of interdependence between modules
belong together
Goal High cohesion is desirable Low coupling is desirable
Focus Internal module structure Relationship between different modules
Improves module clarity, maintainability, and Reduces risk of changes in one module
Impact
reusability affecting others
07. Define modularity in software design.

Ans:- Modularity in software design refers to the practice of dividing a software system into independent,
self-contained units or modules, each responsible for a specific piece of functionality.
Key Characteristics:

 Each module performs a single task or closely related set of tasks.

 Modules can be developed, tested, and maintained independently.
 Modules interact with each other through well-defined interfaces.

Benefits of Modularity:

 Improved maintainability – Easier to update or fix specific parts.

 Enhanced reusability – Modules can be reused in different projects.
 Simplified testing and debugging – Issues can be isolated to individual modules.

08. What is the purpose of a Data Flow Diagram (DFD)?

Ans:- The purpose of a Data Flow Diagram (DFD) is to visually represent how data flows through a
system, showing the processes, data stores, inputs, and outputs involved.

Key Objectives:

1. Understand system functionality – It helps stakeholders and developers see how data moves and is
processed within the system.
2. Identify data sources and destinations – Shows where data comes from, where it goes, and how it's
transformed.
3. Support system design and analysis – Useful in the early stages of system development to define
requirements and spot inefficiencies or missing components.

09. List the types of UML diagrams.

Ans:- Unified Modeling Language (UML) diagrams are broadly categorized into two main types:

1. Structural Diagrams (describe the static structure of a system):

 Class Diagram
 Object Diagram
 Component Diagram
 Deployment Diagram
 Package Diagram
 Composite Structure Diagram

2. Behavioral Diagrams (describe the dynamic behavior of the system):

 Use Case Diagram

 Sequence Diagram
 Activity Diagram
 State (State Machine) Diagram
 Communication Diagram
 Interaction Overview Diagram
 Timing Diagram

 10. Define a design pattern. Give an example.

Ans:- A design pattern is a reusable solution to a common problem that occurs frequently in software
design. It is not code, but a general template or blueprint that can be applied in different situations to solve
design issues efficiently and effectively.

Design patterns help in:

 Improving code reusability

 Enhancing system architecture
 Promoting best practices

Example: Singleton Pattern

Purpose:
Ensures that a class has only one instance and provides a global point of access to that instance.

Use Case:
Used when exactly one object is needed to coordinate actions across a system (e.g., a configuration manager,
logging service, or database connection).

11. What is the use of a class diagram in UML?

Ans:- A class diagram in UML is used to model the static structure of a system by showing:

 The system’s classes

 Their attributes (data)
 Their methods (operations or behaviors)
 The relationships between classes (such as inheritance, association, aggregation, and composition)

Key Uses of a Class Diagram:

1. Visualize the system structure: It helps developers and stakeholders understand how the system is
organized.
2. Define object-oriented design: Shows how objects and classes relate and interact.
3. Guide implementation: Acts as a blueprint for coding by clearly defining classes and their
responsibilities.

12. List any two user interface design principles.

Ans:- Here are two key user interface (UI) design principles:

1. Consistency
Ensure that similar elements behave and appear the same way throughout the interface to help users
learn and predict how things work.
2. Feedback
Provide clear, immediate responses to user actions (like button clicks or form submissions) so users
know their input has been received and what’s happening next.

13. What is unit testing?

Ans:- Unit testing is the process of testing individual components or modules of a software application in
isolation to ensure that each part works correctly on its own.
Key points about unit testing:

 Focuses on the smallest testable parts of the software (usually functions, methods, or classes).
 Helps detect bugs early in the development cycle.
 Typically automated and performed by developers.
 Supports better code quality, easier maintenance, and safer refactoring.

14. Differentiate between black-box and white-box testing.

Ans:- Here’s a clear differentiation between black-box testing and white-box testing:

Aspect Black-Box Testing White-Box Testing

Testing based on functional requirements— Testing based on internal code
Focus
what the software does structure—how the software works
Tester Tester does not need knowledge of the Tester requires knowledge of the code and
Knowledge internal code logic
Tests are designed from specifications, Tests are designed to cover code paths,
Test Design
inputs, and expected outputs branches, conditions
Verify code correctness and internal
Purpose Validate software behavior and outputs
logic
15. Define ISO 9000 in the context of software quality.

Ans:- ISO 9000 in the context of software quality refers to a set of international standards for quality
management systems that help organizations ensure they consistently meet customer and regulatory
requirements, and improve customer satisfaction.

Key points about ISO 9000 in software:

 It provides a framework for quality assurance processes throughout the software development
lifecycle.
 Emphasizes process-oriented approach to managing software quality.
 Helps organizations establish documented procedures, controls, and continuous improvement.

16. What is the purpose of debugging?

Ans:- The purpose of debugging is to identify, isolate, and fix errors or defects (bugs) in a software
program to ensure it runs correctly and meets its intended behavior.

Key objectives of debugging:

 Detect the root cause of a problem or unexpected behavior in the code.

 Correct the faulty code to prevent crashes, incorrect results, or security issues.
 Improve the overall quality, reliability, and stability of the software.
 Help developers understand how the program works and identify potential weaknesses.

17. What is reverse engineering in software?

Ans:- Reverse engineering in software is the process of analyzing a finished software system to extract
knowledge or design information from the existing code or binaries, without access to the original source
code or documentation.

Key points:
  It involves understanding how the software works internally by studying its components,
structure, and behavior.
 Often used for maintenance, debugging, security analysis, or recreating lost documentation.
 Helps in recovering design and requirements when original documents are missing or outdated.
 Can be used to improve, extend, or integrate legacy systems.

18. What are the components of a GUI?

Ans:- The main components of a GUI (Graphical User Interface) typically include:

1. Windows
Containers that hold and organize other GUI elements; they provide a workspace for users.
2. Icons
Small graphical symbols representing programs, files, functions, or commands.
3. Menus
Lists of options or commands that users can select to perform actions.
4. Buttons
Clickable elements that trigger specific actions or commands.

19. Compare and contrast Waterfall, Prototyping, Evolutionary, and Spiral models.

Ans:- Sure! Here's a comparison and contrast of the Waterfall, Prototyping, Evolutionary, and Spiral
software development models:

Aspect Waterfall Model Prototyping Model Evolutionary Model Spiral Model

Iterative risk-driven
Build prototype Iterative
approach combining
Approach Linear and sequential early, refine based development with
design and
on feedback gradual refinement
prototyping
Fixed phases: Multiple Cycles of planning,
Prototype → user
requirements → design → evolutionary releases risk analysis,
Phases feedback → refine
implementation → testing with increasing engineering,
→ final product
→ maintenance functionality evaluation
Focus on early risk
Requirements are
Must be well-understood Requirements can assessment when
Requirements vague or not fully
upfront evolve over time requirements are
known
unclear
High — allows High — adapts based
Low — hard to go back High — adapts as
Flexibility changes based on on risk and feedback
once a phase is completed system evolves
user feedback at each spiral
20. Explain the key responsibilities of a software project manager.

Ans:- The key responsibilities of a software project manager include:

1. Project Planning and Scheduling:

Defining the project scope, objectives, tasks, timelines, and resource allocation to create a clear
roadmap for the project.
2. Resource Management:
Assigning and managing the project team, equipment, and budget to ensure efficient use of
resources.
3. Risk Management:
Identifying potential risks, assessing their impact, and developing mitigation strategies to minimize
project disruptions.
 4. Monitoring and Controlling:
Tracking project progress against the plan, managing changes, resolving issues, and ensuring the
project stays on schedule and within budget.
5. Communication:
Acting as the central point of contact between stakeholders, team members, and clients to ensure
everyone is informed and aligned.
6. Quality Assurance:
Ensuring that the software meets the required quality standards through proper processes, reviews,
and testing oversight.

21. Discuss the COCOMO model in detail with an example.

Ans:- What is COCOMO?

COCOMO (Constructive Cost Model) is a parametric software cost estimation model developed by
Barry Boehm in 1981. It helps estimate the effort, cost, and schedule required to develop a software project
based on the size of the software.

Types of COCOMO

There are three main levels of the COCOMO model:

1. Basic COCOMO
Provides a rough estimate of effort and cost based primarily on the size of the software (measured in
thousands of lines of code — KLOC). It uses predefined formulas based on project types.
2. Intermediate COCOMO
Adds factors for cost drivers like product reliability, complexity, team experience, and tools to adjust
estimates more realistically.
3. Detailed COCOMO
Extends the Intermediate model by considering the impact of cost drivers on each phase of the
software lifecycle.

22. Describe the software configuration management process.

Ans:- SCM is the process of systematically controlling, organizing, and tracking changes in software
during its development and maintenance to ensure integrity, traceability, and consistency throughout the
lifecycle.

Key Activities in the SCM Process:

1. Configuration Identification
o Define and document the configuration items (CIs) such as source code, documents, libraries,
and tools.
o Assign unique identifiers to each item for tracking.
2. Configuration Control
o Manage and control changes to configuration items through formal change control
procedures.
o Review, approve, or reject change requests to prevent unauthorized or conflicting
modifications.
3. Configuration Status Accounting
o Record and report on the status of configuration items and change requests.
 o Provide visibility on versions, baselines, and changes made over time.
4. Configuration Auditing
o Verify that configuration items conform to their specifications and that changes are correctly
implemented.
o Conduct audits to ensure compliance and identify discrepancies.
5. Build Management
o Automate and manage the process of assembling source code and other components into
executable software.
o Maintain repeatability and traceability of builds.
6. Release Management and Delivery
o Control the distribution of software releases to users, ensuring the correct versions and
documentation are delivered.
o Track deployment and updates.

23. Explain cohesion and coupling with suitable examples.

Ans:- Cohesion

Definition:
Cohesion refers to the degree to which the elements inside a single module/class are related to one another.
It measures how focused a module is on a single task or responsibility.

 High cohesion means the module performs one well-defined task.

 Low cohesion means the module handles unrelated tasks, making it harder to maintain.

Example:

 High Cohesion:
A class InvoiceCalculator that only handles calculations related to invoices — like calculating
totals, taxes, and discounts. All methods relate to one purpose: invoice calculations.
 Low Cohesion:
A class Utility that has methods for calculating invoices, printing reports, managing user
authentication, and handling file I/O. This class is doing many unrelated things.

24. Describe the SA/SD methodology. How is it useful in design?

Ans:- ere’s an explanation of the SA/SD methodology and its usefulness in design:

What is SA/SD?

SA/SD stands for Structured Analysis and Structured Design — a traditional, systematic methodology
used in software engineering for analyzing and designing information systems.

 Structured Analysis (SA): Focuses on understanding and modeling what the system must do
(requirements analysis).
 Structured Design (SD): Focuses on how to implement the system based on the analysis (system
design).

Components of SA/SD
 1. Structured Analysis
o Uses tools like Data Flow Diagrams (DFDs) to represent the flow of data through the
system.
o Helps identify processes, data stores, inputs, outputs, and how they interact.
o Emphasizes clear, hierarchical decomposition of system functions.
2. Structured Design
o Converts the analysis models into modular, manageable designs.
o Uses tools like Structure Charts to define modules, their hierarchy, and interactions.
o Focuses on designing software components with clear responsibilities and interfaces.

How is SA/SD Useful in Design?

 Clarity and Organization: Breaks down complex systems into smaller, understandable parts,
making design easier to manage.
 Modularity: Promotes modular design, improving maintainability and reusability.


25. Differentiate between function-oriented and object-oriented design.

Ans:- Sure! Here's a clear comparison between Function-Oriented Design (FOD) and Object-Oriented
Design (OOD):

Aspect Function-Oriented Design (FOD) Object-Oriented Design (OOD)

Focuses on functions or processes that Focuses on objects that combine data and
Focus
transform data behavior
Basic Unit of
Functions or procedures Objects (classes and instances)
Design
Data and functions are separate; data is Data and functions (methods) are
Data Handling
passed to functions encapsulated within objects
Divides system into functions or
Modularity Divides system into interacting objects
modules
Approach Top-down design approach Bottom-up or iterative approach
Limited; data structures are simple and
Data Abstraction Strong encapsulation and abstraction of data
exposed
High reusability through inheritance and
Reusability Function reuse is possible but limited
polymorphism
Examples of
C, Pascal Java, C++, Python
Languages
Real-world Less intuitive modeling of real-world Better models real-world entities and
Modeling entities relationships
26. Explain the various UML diagrams and their roles in software development.

Ans:- Here’s an overview of the various UML (Unified Modeling Language) diagrams and their roles in
software development:

UML Diagrams: Two Main Categories

1. Structural Diagrams (show the static structure of a system)

 2. Behavioral Diagrams (show dynamic behavior and interactions)

1. Structural Diagrams

Diagram Purpose/Role

Shows classes, attributes, methods, and relationships; core for designing object-oriented
Class Diagram
systems.

Object Diagram Snapshot of instances (objects) at a specific time; useful for understanding system state.

Models physical components (e.g., files, executables) and their dependencies; helps in
Component Diagram
deployment planning.

Shows hardware nodes and software components deployed on them; important for
Deployment Diagram
system architecture and deployment.

Organizes model elements into packages (modules); helps manage large systems by
Package Diagram
grouping related classes.

Composite Structure Shows internal structure of a class and interactions among parts; useful for detailed
Diagram design.

Roles in Software Development

 Requirement Analysis: Use Case Diagrams help capture functional requirements clearly.
 System Design: Class, Package, Component, and Deployment Diagrams aid in designing system
architecture and organization.
 Detailed Design: Sequence, Communication, State Machine, and Activity Diagrams specify detailed
behavior and interactions.
 Implementation Support: Diagrams guide developers and help in writing code aligned with design.
 Testing: Behavioral diagrams help testers understand scenarios and expected behaviors.

27. Discuss any three design patterns with examples.

Ans:- bsolutely! Here are three common design patterns explained with simple examples:

1. Singleton Pattern

Purpose:
Ensure that a class has only one instance throughout the application and provide a global point of access to
it.

Example Use Case: Logger system, configuration manager.

Example (Python):

python
CopyEdit
class Singleton:
_instance = None

def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance

# Usage
obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2) # True, both are same instance

2. Observer Pattern

Purpose:
Define a one-to-many dependency between objects so when one object changes state, all its dependents are
notified automatically.

Example Use Case: Event handling systems, GUI frameworks, or subscription services.

Example (Python):

python
CopyEdit
class Subject:
def __init__(self):
self._observers = []

def register(self, observer):

self._observers.append(observer)

def notify(self, message):

for observer in self._observers:
observer.update(message)

class Observer:
def update(self, message):
print(f"Received message: {message}")

# Usage
subject = Subject()
observer1 = Observer()
subject.register(observer1)
subject.notify("Hello observers!")

3. Factory Method Pattern

Purpose:
Define an interface for creating an object but let subclasses decide which class to instantiate.

Example Use Case: Creating objects without specifying exact class types, like document generators.

Example (Python):

python
CopyEdit
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Woof!"

class Cat(Animal):
def speak(self):
return "Meow!"

class AnimalFactory:
@staticmethod
def create_animal(animal_type):
if animal_type == "dog":
return Dog()
elif animal_type == "cat":
return Cat()
else:
return None

# Usage
factory = AnimalFactory()
animal = factory.create_animal("dog")
print(animal.speak()) # Output: Woof!

28. Describe the Object-Oriented Design (OOD) process.

Ans:- What is Object-Oriented Design (OOD)?

OOD is the process of planning a system of interacting objects for the purpose of solving a software
problem. It focuses on identifying objects, their behaviors, and interactions to build a modular and reusable
software system.

Key Steps in the OOD Process

1. Identify Objects and Classes

o Analyze requirements to find key objects (things/entities) involved in the system.
o Group similar objects into classes that define common attributes and behaviors.
2. Define Class Responsibilities
o Assign clear responsibilities to each class (what it should do).
o Ensure each class has a focused purpose to promote high cohesion.
3. Establish Relationships Between Classes
o Identify how classes interact via associations, inheritance, aggregation, or composition.
o Define the nature of relationships (one-to-one, one-to-many).
4. Design Class Interfaces and Methods
o Specify the public methods through which objects interact.
o Determine attributes (data members) that objects hold.

29. Describe the methodology of GUI design.

Ans:- What is GUI Design Methodology?

GUI design methodology is a structured approach used to create user interfaces that are intuitive, efficient,
and user-friendly. It ensures that users can interact with software easily and effectively.

Key Steps in GUI Design Methodology

 1. Requirement Analysis
o Understand the target users, their tasks, and goals.
o Gather functional and non-functional requirements related to usability.
2. User and Task Analysis
o Identify user characteristics (experience, preferences).
o Analyze tasks users need to perform and their workflow.
3. Design Conceptualization
o Define the overall look and feel (layout, theme, style).
o Plan navigation flow and how users will interact with elements.
4. Prototyping
o Create wireframes or mockups to visualize the interface.
o Use low-fidelity (sketches) or high-fidelity (interactive) prototypes.
o Helps gather early feedback from users and stakeholders.

30. Explain the different types of software testing techniques.

Ans:- ere’s a rundown of the different types of software testing techniques, categorized broadly into
functional and non-functional testing, along with their key points:

1. Functional Testing Techniques

These test what the software does, ensuring it meets specified requirements.

 Unit Testing
Tests individual components or modules in isolation to verify correctness.
Example: Testing a single function or method.
 Integration Testing
Tests combined parts of the system to ensure they work together properly.
Example: Testing data flow between two modules.
 System Testing
Tests the complete and integrated software to verify it meets requirements.
Example: Running the entire application in an environment simulating production.
 Acceptance Testing
Validates the system against user requirements to decide if it is ready for delivery.
Example: User Acceptance Testing (UAT) performed by end users.
 Regression Testing
Ensures new code changes have not adversely affected existing functionality.
Example: Retesting features after bug fixes.

2. Non-Functional Testing Techniques

These test how the software performs under various conditions.

 Performance Testing
Checks the responsiveness, stability, and scalability under load.
Example: Load testing to simulate many users.
 Stress Testing
Tests software under extreme conditions beyond normal operational capacity.
Example: Overloading the system to find breaking points.
  Usability Testing
Assesses how user-friendly and intuitive the interface is.
Example: Observing users performing tasks to identify difficulties.
 Security Testing
Identifies vulnerabilities and ensures data protection.
Example: Penetration testing or vulnerability scanning.
 Compatibility Testing
Verifies software works across different devices, browsers, or OS versions.
Example: Checking if a web app runs on Chrome, Firefox, and Safari.

3. Testing Based on Knowledge of Internal Code

 White-Box Testing (Structural Testing)

Testing based on knowledge of the internal logic and structure of the code.
Example: Code coverage testing, path testing.

31. Describe software maintenance and its process models.

Ans:- Here’s an explanation of software maintenance and its process models:

What is Software Maintenance?

Software maintenance refers to the activities performed after the delivery of software to correct faults,
improve performance, or adapt the software to a changed environment. It ensures the software continues to
meet user needs and operates efficiently over time.

Types of Software Maintenance

1. Corrective Maintenance
Fixing bugs and defects found after deployment.
2. Adaptive Maintenance
Modifying software to work in a changed environment (e.g., new OS, hardware).
3. Perfective Maintenance
Enhancing or improving features and performance based on user feedback.
4. Preventive Maintenance
Updating software to prevent future problems or improve maintainability.

Software Maintenance Process Models

Several models guide how maintenance is carried out efficiently. Here are key process models:

1. Iterative Enhancement Model

 Maintenance is treated as a series of small, incremental enhancements or fixes.

  Each iteration involves analyzing the problem, designing a solution, implementing changes, testing,
and deploying.
 Allows gradual improvement and frequent updates.

32. What are program analysis tools? Discuss their role in debugging.

Ans:- ere’s an explanation of program analysis tools and their role in debugging:

What Are Program Analysis Tools?

Program analysis tools are software tools that help developers examine and understand code. They analyze
the source code or executable to detect errors, ensure quality, improve performance, and verify correctness.

Types of Program Analysis Tools

 Static Analysis Tools

Analyze source code without executing the program. They check for syntax errors, coding standard
violations, possible bugs, security vulnerabilities, and code complexity.
Examples: Linters, static code analyzers (like SonarQube, Coverity).
 Dynamic Analysis Tools
Analyze program behavior during execution to detect runtime errors, memory leaks, performance
bottlenecks, etc.
Examples: Debuggers, profilers, memory analyzers (like Valgrind).