1. Explain the Classical Waterfall Model and its phases. 5. Describe Decision Trees and Decision Tables.

5. Describe Decision Trees and Decision Tables. Compare their uses in system modeling.
The Classical Waterfall Model is one of the earliest and most structured software development life cycle (SDLC) Decision trees and decision tables are tools used to represent and analyze complex decision logic within a
models. It follows a linear and sequential approach where each phase must be fully completed before the next system. They help identify actions based on different conditions.
begins. It is best suited for projects with clear, stable, and well-understood requirements. Decision Tree: A graphical representation where each node represents a condition and each branch represents
Phases: an outcome. It is suitable for problems involving sequential decisions with limited conditions.
1. Feasibility Study: Evaluates technical, operational, and financial feasibility to determine if the project is Decision Table: A tabular representation listing all possible condition combinations and corresponding actions.
viable. It ensures completeness and consistency, making it useful for systems with multiple interdependent conditions.
2. Requirements Analysis and Specification: Involves gathering and documenting all system requirements in a Comparison:- -Decision trees are more visual and easier for simple logic.
Software Requirement Specification (SRS). - Decision tables handle complex combinations systematically.
3. System Design: Defines architecture, modules, data flow, and interfaces based on the SRS to guide Example: In a loan approval system, a decision tree can show approval steps, while a decision table lists all
implementation. condition combinations like income, credit score, and loan amount.
4. Coding: Developers convert design into executable code using appropriate programming languages. Summary: Decision trees are best for visualization; decision tables are best for ensuring logical completeness.
5. Testing: Includes unit, integration, and system testing to identify and fix defects ensuring the system meets 6. Explain Modularity, Cohesion, and Coupling in Software Design.
specified requirements. Modularity, cohesion, and coupling are fundamental software design principles that enhance maintainability,
6. Maintenance: After deployment, the software undergoes updates to correct errors or adapt to new clarity, and reusability.
environments. Modularity: The division of software into independent modules that perform specific tasks. It allows easier
Advantages: Well-defined structure, easy management, and clear documentation. debugging, parallel development, and scalability.
Disadvantages: Inflexible to changes, limited user feedback, and late detection of errors. Cohesion: Describes how closely related functions within a module are. High cohesion means all elements
Summary: The Waterfall Model is simple and disciplined but less adaptable, making it ideal for small to medium contribute to a single purpose, improving module clarity and reusability.
projects with fixed requirements. Coupling: Refers to the interdependence between modules. Low coupling is preferred since it reduces
2. Compare Waterfall, Prototype, and Spiral Software Process Models. complexity and allows independent changes.
Software process models define how software is developed and managed. The Waterfall, Prototype, and Spiral Example: A user authentication module with login and password reset functions is cohesive, while modules
models differ in approach, flexibility, and risk handling. interacting only via APIs exhibit low coupling.
Waterfall Model: Follows a sequential flow through phases like requirements, design, implementation, and Summary: High cohesion and low coupling lead to better software quality and easier maintenance.
testing. Once a phase is complete, it cannot be revisited. It’s best for projects with well-defined and stable 7. What is a Level 0 Data Flow Diagram (DFD)? Provide an Example.
requirements. A Level 0 Data Flow Diagram (DFD) is a high-level representation of the entire system as a single process. It
Prototype Model: Focuses on building an early prototype of the system to clarify requirements through user shows the system’s boundaries, external entities, and major data flows without internal details.
feedback. The prototype evolves until the client is satisfied, making it ideal for projects with unclear or Steps to Create:
changing requirements. 1. Identify external entities interacting with the system.
Spiral Model: Combines iterative development with risk analysis. Each spiral includes planning, risk analysis, 2. Determine the main process representing the whole system.
engineering, and evaluation. It is suitable for large and high-risk projects where requirements evolve over time. 3. Identify major inputs, outputs, and data stores.
Comparison Summary: Waterfall is rigid but simple; Prototype emphasizes user feedback and flexibility; Spiral Example: In an ATM system, the user (external entity) provides card and PIN as input, and the system outputs
focuses on risk management and iterative improvement. cash or messages. This gives an overview without showing sub-processes.
3. What is a Software Requirement Specification (SRS)? Discuss its key characteristics. Importance: Level 0 DFD establishes system scope and forms the foundation for lower-level DFDs (Level 1,
A Software Requirement Specification (SRS) is a formal document that describes what the software system Level 2) with detailed processes.
should do and how it should perform. It acts as a communication bridge between the client and the 10. Draw and Explain the Data Flow Diagram (DFD) for a Banking System
development team, serving as a foundation for design, coding, and testing. A Data Flow Diagram (DFD) visually represents how data moves through a banking system. It shows the flow of
An SRS typically includes: Introduction, overall system description, functional and non-functional information between external entities, system processes, and data stores. The DFD helps understand the
requirements, interfaces, and constraints. overall functionality and data interactions within the system.
Characteristics of a Good SRS: Level 0 DFD (Context Diagram):
- Correct: Accurately defines system requirements. The Level 0 DFD provides a high-level view of the entire banking system as a single process.
- Unambiguous: Each requirement is clearly stated. External Entities:
- Complete: Covers all scenarios and responses. Customer: Performs activities such as depositing, withdrawing, transferring funds, and checking balance.
- Consistent: No conflicts between requirements. Bank Staff: Manages accounts, verifies transactions, and updates records.
- Verifiable: Can be tested or measured. ATM / Online Portal: Acts as an interface for customers to perform digital banking activities.
- Modifiable: Easy to update. Main Process:
- Traceable: Each requirement can be tracked through development. Banking System: Handles customer requests and updates the database accordingly.
Summary: A well-prepared SRS ensures clear understanding, minimizes rework, and forms the basis for Data Flows: From Customer → Transaction details (Deposit/Withdrawal requests).
successful software development From Banking System → Receipts, confirmations, and balance details.
4. Differentiate Functional and Non-Functional Requirements with Examples. From Staff → Account updates, verifications.
In software engineering, requirements are classified as functional or non-functional. Understanding both Data Stores: Customer Database: Contains customer personal and account details.
ensures the system performs its intended tasks effectively and efficiently. Transaction Database: Stores all transaction records.
Functional Requirements: Describe specific functionalities or services the system should provide. They define Level 1 DFD (Detailed View):
inputs, processing, and outputs. Example: 'The system shall allow users to log in using a valid username The system is divided into major processes:
and password.' 1. Account Management: Creates, updates, and closes customer accounts.
Non-Functional Requirements (NFRs): Define the quality attributes of the system such as performance, 2. Transaction Processing: Handles deposits, withdrawals, and fund transfers.
security, usability, and reliability. 3. Loan Management: Processes loan applications, payments, and approvals.
Examples: - Performance: 'System must load the dashboard within 2 seconds.' 4. Report Generation: Produces statements and daily reports.
- Security: 'Data must be encrypted during storage and transmission.' Data Flow Example:
- Usability: 'Interface must be accessible to all users including those with disabilities.' Customer submits withdrawal → Transaction Processing verifies account and balance → Updates Transaction
Both are equally important — functional defines 'what' the system does, while non-functional defines 'how
Database → Sends confirmation to Customer.
well' it does it.

8. Define Object-Oriented Concepts: Object, Class, Inheritance, Association, Aggregation, and

Composition.
Object-oriented concepts represent the building blocks of OOP. They help design software systems that mirror
real-world entities and relationships.
Object: An instance with state (attributes) and behavior (methods). Example: A specific car with color and
model details.
Class: A blueprint that defines common attributes and methods for objects.
Inheritance: Enables a new class to inherit properties and methods from an existing class, supporting
reusability.
Association: A general relationship between classes, such as a 'Customer' placing multiple 'Orders.'
Aggregation: A whole-part relationship where parts can exist independently, e.g., a 'Library' containing 'Books.'
Composition: A stronger form of aggregation where parts cannot exist without the whole, e.g., a 'House'
composed of 'Rooms.'
These concepts promote modularity, code reuse, and logical organization of complex systems.
9. Advantages of Object-Oriented Design.
Object-Oriented Design (OOD) organizes software around objects representing real-world entities with
properties and behaviors. This paradigm offers extensive advantages for building complex, maintainable, and
scalable softwaree. Advantages: Code and Design Reuse: Through inheritance and polymorphism,
existing classes and components can be extended or specialized without rewriting code, saving time and
ensuring consistency.
Encapsulation: Bundling data and methods protects internal state and reduces system complexity by exposing
only necessary interfaces, improving robustness.
Improved Maintainability: Encapsulation and modularity localize changes within classes, reducing side effects
across the system, simplifying debugging and updates.
Natural Modeling of Real-world Problems: OOD maps software entities to real-world concepts, making designs
more intuitive and easier to understand, facilitating clearer communication among developers and
stakeholders.
Enhanced Productivity: Leveraging reusable libraries, frameworks, and rapid prototyping in OOD accelerates
development cycles.
Better Testing and Debugging: Independent objects or classes can be unit tested in isolation, enabling early
detection and correction of defects.
Extensibility and Scalability: New features can be introduced by subclassing or adding new classes with
minimal impact on existing system components.
1. Classical Waterfall Model
• Phases: Feasibility Study, Requirements Analysis and Specification, Design, Coding, Unit Testing,
Integration and System Testing, Maintenance.
2. Iterative Waterfall Model:-Iterates phases of Waterfall allowing limited reuse and feedback between
phases.
3. Prototype Model
• Focuses on building rapid prototypes to gather user feedback and refine requirements iteratively.
4. Incremental Software Development/Evolution Model
Develops the software in increments or modules, delivering partial working versions early and
progressively enhancing them.
5. Spiral Model:- Combines iterative development with risk analysis, cycling through planning, risk
resolution, engineering, and evaluation repeatedly.
6. V-Model (Verification and Validation Model)
• Extends Waterfall by mapping testing types to each development phase; emphasizes early testing
planning and strong validation.
7. Big Bang Model
• No formal process; software is developed with raw effort and money input, often producing
unpredictable results.
8. Agile Model:- Combines iterative and incremental approaches with a focus on adaptability, customer
collaboration, and rapid delivery of working software. Includes methods like Scrum, Extreme Programming
(XP), RAD, etc.
9. Rapid Application Development (RAD) Model
• Based on prototyping and iterative development with minimal planning, focusing on faster delivery and
active user involvement.
10. Extreme Programming (XP):- Practices best development techniques to extreme levels including rapid
releases, continuous feedback, and user involvement.
11. Scrum Model:-A framework dividing the project into small time-boxed iterations (sprints), with
continuous stakeholder involvement and flexibility to changes.