🌊 What Is the Waterfall Model?
The Waterfall Model—also called the Linear Sequential Model—is a traditional software development methodology where each phase
flows into the next like a waterfall. It’s simple, structured, and ideal for projects with well-defined requirements.
🧱 Phases of the Waterfall Model
Each phase has a distinct goal and must be completed before moving to the next:
Phase Description
System/Information Engineering Understand and define the overall system requirements. A subset is allocated to software.
Requirement Analysis Focuses on gathering and analysing software-specific requirements.
Design Translates requirements into a blueprint for building the software.
Coding Converts the design into actual code using programming languages.
Testing Verifies that the software meets user requirements and functions correctly.
Implementation & Maintenance Delivers the software to users and handles updates or fixes post-deployment.
✅ Advantages
Easy to understand and manage.
Clear structure with defined milestones.
Good for projects with fixed requirements.
Helps control budget, schedule, and documentation.
❌ Disadvantages
No flexibility for changing requirements mid-project.
No working software until late in the process.
Minimal user involvement during development.
No built-in risk management.
Assumes requirements are stable and complete from the start.
📌 When to Use It
Projects with well-understood and stable requirements.
Regulatory or documentation-heavy environments.
When clarity and predictability are more important than adaptability.
Question:
Software Engineering Approach
The Software Engineering Approach focuses on how software is developed—not just the final product. It
emphasizes structured processes to ensure quality, efficiency, and reliability.
🔄 Two Key Goals
1. Phased Development Process
2. Project (Process) Management
1️⃣ Phased Development Process
This breaks down software development into distinct phases, each with a specific goal:
Requirement Analysis Understand the problem and document what the software must do.
Software Design Plan the solution by translating requirements into a system architecture.
Coding Convert the design into executable code using programming languages.
Testing Verify the software works correctly and meets requirements.
Each phase builds on the previous one, making complex projects more manageable.
2️⃣ Project (Process) Management
This ensures the development process runs smoothly:
Planning and Scheduling Allocate resources, set timelines, and define milestones.
Monitoring and Control Track progress, manage risks, and adjust plans as needed.
Software Metrics Use measurable data to assess product quality and process efficiency:
o Product Metrics: Evaluate the software itself (e.g., size, complexity).
o Process Metrics: Evaluate how the software is developed (e.g., time, cost).
🎯 Why This Approach Matters
Reduces complexity
Minimizes cost and time
Improves reliability and productivity
Supports large-scale project
UNIT – 2
🧠 System Design Principles
System design is the phase where the software’s architecture is
crafted to meet requirements efficiently and simply. The goal is
to create a verifiable, complete, and traceable design that
works well within its environment.
🔑 Key Principles
1. Efficiency and Simplicity
Efficiency: Use resources wisely—CPU, memory, time.
Simplicity: Easier to maintain and debug. Complex
systems are costly to fix.
2. Problem Partitioning & Hierarchy
Break large problems into smaller, manageable parts.
Use the “Divide and Conquer” strategy.
Results in a hierarchy of components, making the
system easier to understand and build.
3. Abstraction
Focus on what a component does, not how it does it.
Two types:
o Functional Abstraction: Define modules by their
function (e.g., log calculator).
o Data Abstraction: Define modules by the data they
handle.
4. Modularity
Divide the system into independent modules.
Each module should be:
o Solvable and modifiable separately.
o Ideally, compliable on its own.
Helps with debugging, testing, and maintenance.
5. Top-Down vs. Bottom-Up Design
Top-Down: Start from the big picture, break it down into
smaller parts.
Bottom-Up: Start with basic components, build up to the
full system.
Choose based on project needs and clarity of
specifications.
These principles guide designers to build software that’s not
only functional but also maintainable and scalable.
🧩 Structure Chart in Software Design
A Structure Chart is a graphical representation used in
function-oriented design to show how a software system is
organized. It helps visualize the hierarchy of modules and
their interconnections, making the design easier to
understand and communicate.
📐 Key Features
Modules as Boxes: Each module is shown as a box with
its name inside.
Hierarchy: Arrows show which module calls which—called
superordinate (caller) and subordinate (callee).
Data Flow: Arrows are labelled with input/output
parameters and show the direction of data flow.
Looping & Decisions:
o Looping Arrows: Indicate repeated calls to modules.
o Diamonds: Represent decision points that control
which modules are called.
🔄 Types of Modules
Transform Modules: Focus on converting data from one
form to another (e.g., calculations).
Coordinate Modules: Manage the flow of data between
subordinates.
A module can serve multiple roles depending on its
function.
🎯 Purpose and Benefits
Clarifies the functional decomposition of the system.
Highlights module relationships and data exchange.
Supports modularity, abstraction, and hierarchical
design.
Makes it easier to evaluate, debug, and maintain the
system.