Software Engineering

Complete Notes — All 4 Units

BCA-63T-205 | Rajasthan University | Hinglish

Paper: 120 Marks | 20×4(OR) + 2×10 + 10×4(Attempt 2)

Unit Topic Marks Weight

Unit I Software Fundamentals & Process Models High

Unit II Project Planning, Cost Estimation, Quality High

Unit III Design Engineering & Testing Very High

Unit IV Reliability, Maintenance & Reengineering High

 UNIT I: Software Engineering Fundamentals & Process Models

Chapter 1: Software & Software Engineering

What is Software?

Software = Instructions (programs) + Data structures + Documents ka collection jo milke ek useful

system banate hain.

Software ke Types:

Type Matlab Example

System Software Hardware manage karna OS, Compiler, Drivers

Application End users ke liye MS Word, Chrome, Tally

Software

Embedded Hardware mein built-in Washing machine, ATM

Software

Real-time Software Time-critical operations Flight control, ICU monitors

Web Applications Internet-based Banking apps, Social media

AI Software Intelligent behavior Chatbots, Recommendation systems

Software Engineering — Definition & Challenges

Software Engineering (IEEE): 'The application of a systematic, disciplined, quantifiable approach

to the development, operation, and maintenance of software.'

Software Engineering Challenges:

• Scale: Bada system banana — complexity bahut badhti hai
• Quality: Bugs-free software banana difficult hai
• Cost: Budget mein rehna mushkil hota hai
• Time: Deadline pe deliver karna — mostly projects late ho jaate hain
• Changing Requirements: Client requirements badalte rehte hain
• Team Coordination: Bade teams mein communication mushkil

Problem Domain

Problem Domain = Woh area/field jis problem ko solve karna hai. Example: Hospital management
system ka problem domain = hospitals, patients, doctors, medicines. Software engineer ko PEHLE
problem domain achhi tarah samajhna hota hai.

Software Process — 3Ps (Process, Project, Product)

 Component Matlab Example

Process Software banane ki step-by-step Waterfall, Agile

method

Project Specific software develop karne Banking app project

ka effort (time, cost, team)

Product Final software jo deliver hota hai ATM software, WhatsApp

Software Requirement Analysis & Specification (SRS)

SRS (Software Requirements Specification) = Ek document jo clearly describe karta hai ki

software kya karega. Yeh 'contract between client and developer' hota hai.

Requirements ke Types:
• Functional Requirements: System kya functions karega — 'User login kar sakta hai', 'Report
generate hogi'
• Non-Functional Requirements: System kaise karega — performance, security, reliability, scalability
• Domain Requirements: Business domain ke specific rules — banking regulations

Exam Gold: SRS = 'Contract between client and developer' — yeh line 20-mark answers mein
zaroor likhna!

Chapter 2: Software Development Process Models

1. Waterfall Model

Waterfall Model = Sabse purana aur simple linear sequential model. Ek phase complete hone ke
baad hi doosra start hota hai — wapas nahi ja sakte. Jaise paani upar se neeche girta hai.

Phases (sequence mein):

Requirements → System Design → Implementation (Coding) → Testing → Deployment → Maintenance

Advantages Disadvantages

Simple aur easy to understand Requirements change nahi ho sakti — rigid hai

Documentation achhi hoti hai Late stages mein errors milna costly hai

Small projects ke liye best Customer working software late dekhta hai

Progress easily measurable Real projects rarely sequential hote hain

Best suited for: Well-defined, stable requirements wale projects jisme changes expected na hon.

2. Prototyping Model

Prototyping = Pehle ek incomplete working model (prototype) banana — client ko dikhao,

feedback lo, phir improve karo. 'Build to throw away' approach.
 • Throwaway Prototype: Sirf testing ke liye — baad mein delete
• Evolutionary Prototype: Improve karte karte final product banta hai

Advantages Disadvantages

User requirements clearly samajh aate hain Client sochta hai yeh final product hai

Misunderstandings early catch hoti hain Poor documentation

User satisfaction zyada hoti hai Unlimited revisions ho sakti hain

3. Iterative Enhancement Model

Iterative Model = Software ko iterations (cycles) mein develop karo. Har iteration mein ek working
version deliver hota hai jisme naye features add hote hain.

• Har iteration = mini waterfall (requirements → design → code → test)

• Pehle core features develop karo, phir dhire dhire enhance karo
• Working software early milti hai
• Requirements change accommodate kar sakta hai

4. Spiral Model

Spiral Model (Barry Boehm, 1986) = Risk-driven model jisme iterative development + systematic
risk analysis combine hoti hai.

4 Quadrants of each spiral:

• Quadrant 1: Objectives determination — goals, constraints define karo
• Quadrant 2: Risk assessment — risks identify karo aur mitigate karo, prototype banao
• Quadrant 3: Development & Testing — code karo aur test karo
• Quadrant 4: Planning for next iteration — next spiral ki planning

Advantages Disadvantages

Risk management best hai Complex model — expertise chahiye

Large, high-risk projects ke liye ideal Costly — zyada time aur resources

Flexible — changes accommodate End point fix nahi hota easily

Exam Tip: Spiral Model = Risk-driven model by Barry Boehm. 'Risk analysis' iska UNIQUE feature
hai!

5. Agile Model

Agile = Modern, flexible approach jisme software chhote chhote sprints (2-4 weeks) mein develop
hota hai. Customer collaboration aur quick delivery pe focus.

Agile Manifesto — 4 Core Values:

• Individuals & interactions over processes & tools
• Working software over comprehensive documentation
 • Customer collaboration over contract negotiation
• Responding to change over following a plan

Various Agile Process Models:

Model Key Feature How it works

Scrum Sprints + roles 2-4 week sprints, daily standup, Sprint review

XP (Extreme Engineering practices Pair programming, TDD, continuous integration

Programming)

Kanban Visual workflow Board: To Do → In Progress → Done

DSDM Timeboxed delivery Fixed time and cost, flexible features

FDD Feature-driven Features list banao, phir ek ek develop karo

Basis Waterfall Agile

Approach Sequential, rigid Iterative, flexible

Customer involvement Beginning aur end mein Throughout project

Delivery End mein ek baar Har sprint ke baad

Requirements change Difficult Welcome hai

Documentation Heavy Minimal

Best for Fixed requirements Changing requirements

 UNIT II: Software Project Planning, Cost Estimation & Quality
Assurance

Chapter 1: Software Project Planning & Cost Estimation

Cost Estimation kya hai?

Cost Estimation = Software project ki development cost pehle se predict karna — time, effort,
resources aur money estimate karna.

Uncertainties in Cost Estimation:

• Requirement uncertainty: Requirements abhi puri clear nahi hain
• Technology uncertainty: New technology use ho rahi hai — experience nahi
• Team uncertainty: Team ki skill set unclear
• Environment uncertainty: Development tools, infrastructure
• Project complexity: Bada project = zyada uncertainty

Cost Estimation Techniques:

Technique Matlab

Expert Judgment Experienced people se estimate karwao

Analogous Estimation Past similar projects se compare karo

Algorithmic/Parametric (COCOMO) Mathematical formulas use karo

Bottom-Up Estimation Har component alag estimate karo, phir jodo

Top-Down Estimation Overall project estimate, phir tod ke dekho

COCOMO Model — Most Important!

COCOMO (Constructive Cost Model) — Barry Boehm ne diya. Software development ki cost aur
time estimate karne ka algorithmic model. LOC (Lines of Code) pe based hai.

COCOMO ke 3 Levels:
• Basic COCOMO: Simple estimate — sirf project size (KLOC) se
• Intermediate COCOMO: 15 cost drivers add kiye — more accurate
• Detailed COCOMO: Most accurate — har phase ke liye alag estimate

Basic COCOMO Formulas:

Effort (E) = a × (KLOC)^b person-months Development Time (T) = c × (E)^d months People (P) =
E / T KLOC = Kilo Lines of Code (thousands of lines)

Mode Project Type a b c d

 Organic Small, simple (payroll 2.4 1.05 2.5 0.38
system)

Semi-detached Medium complexity (banking) 3.0 1.12 2.5 0.35

Embedded Complex, real-time (flight 3.6 1.20 2.5 0.32

control)

Exam Tip: COCOMO = Boehm ka model, LOC based. Formula: E = a × (KLOC)^b.

Organic/Semi-detached/Embedded — teen modes yaad karo!

Chapter 2: Project Scheduling & Milestones

Project Scheduling = Project ke tasks ko timeline pe arrange karna — kaun kab karega, kitna time
lagega, kya dependencies hain.

Scheduling Tools:

Tool Matlab Use

Gantt Chart Bar chart jo tasks aur unki Simple timeline visualization
timeline dikhata hai

PERT Chart Network diagram — tasks ke Complex project dependencies

beech dependencies

CPM (Critical Path Method) Longest path dhundta hai jo Finding critical activities
project completion determine
karta hai

WBS (Work Breakdown Project ko chhote manageable Task organization

Structure) tasks mein todna

Average Duration Estimation — PERT Formula:

Expected Time (te) = (O + 4M + P) / 6 O = Optimistic time (best case) M = Most likely time (normal
case) P = Pessimistic time (worst case)

Milestone = Project mein important checkpoint — ek phase complete hone ka marker. Example:
'SRS document approved', 'Prototype ready', 'Testing complete'. Progress track karne aur client
ko update dene ke liye useful.

Chapter 3: Quality Assurance — Verification, Validation, Inspection &

Reviews

Basis Verification Validation

Question 'Are we building the product 'Are we building the RIGHT product?'
RIGHT?'
 Focus Process check — specification Product check — user ki need puri ho rahi
follow ho rahi hai? hai?

When Development ke dauran (early Development ke baad (end mein)

stages)

Done by QA team internally Customer/End user ke saath

Techniques Reviews, walkthroughs, inspections Testing (unit, integration, system, UAT)

Example Code review — coding standards User acceptance testing — user happy
follow hue? hai?

Exam Gold: Verification = 'Building product right?' | Validation = 'Building right product?' — Yeh
distinction 2-mark aur 20-mark dono mein frequently aata hai!

Inspection & Reviews:

Software Inspection (Fagan Inspection) = Formal process jisme code/document ko carefully

examine kiya jaata hai defects dhundne ke liye — testing se PEHLE. Roles: Moderator, Author,
Reader, Inspector, Scribe.

Review Type Formality Purpose

Walkthrough Informal Author apna code team ko

explain karta hai

Technical Review Semi-formal Technical issues focus — peers

review

Formal Inspection Formal Structured, roles defined,

checklist based

Audit Very formal Independent team — compliance

check

Reviews early mein defects pakad lena = Testing ke baad pakadne se 10x sasta hota hai!
 UNIT III: Design Engineering & Testing Strategies

Chapter 1: Design Engineering

Software Design = Requirements ko ek blueprint mein translate karna jisse code likha ja sake.
'What to build' se 'How to build' ki taraf jaana.

Design Concepts — 6 Core Concepts:

1. Abstraction = Complex details chhupa do, sirf essential information dikhao. Types: Procedural
abstraction (function ka naam), Data abstraction (data structure hide karna).

2. Architecture = Software ka overall structure — modules/components kaise organized hain aur

kaise interact karte hain. System ka blueprint.

3. Modularity = Software ko independent modules mein divide karna. Har module ka ek specific
job hota hai. Easy to understand, test, aur maintain.

4. Functional Independence = Har module apna kaam independently kare. Cohesion = Module ke
andar elements kitne closely related hain (HIGH = GOOD) Coupling = Modules ke beech
dependency (LOW = GOOD) Goal: HIGH Cohesion + LOW Coupling!

5. Refinement (Stepwise Refinement) = Pehle high-level design banao, phir dhire dhire detail add
karo. Top-down approach.

6. Design Classes = OOP concepts — class ka design karna attributes aur methods ke saath.

Exam Tip: 'High Cohesion + Low Coupling = Best module design' — yeh statement 20-mark
answers mein zaroor likhna!

The Design Model — 5 Elements:

Design Element Kya design hota hai Example

Data Design Data structures aur databases ER diagram, database tables

Architectural Design System ka overall structure Client-server, MVC pattern

Interface Design UI aur external system Screen layouts, API design

connections

Component-level Individual modules ka internal Flowchart, pseudocode

Design design

Deployment-level Software kaise deploy hoga Server config, cloud setup

Design

Chapter 2: Testing Strategies & Tactics

 Software Testing = Software mein defects/bugs dhundne ki process. Goal: Software ko fail karwao
(bugs nikalo) BEFORE customer use kare.

Testing Levels:

1. Unit Testing = Smallest testable part (function/method/module) ko individually test karna.

Developer khud karta hai. White-box testing use hoti hai.

2. Integration Testing = Multiple units ko combine karke test karna — unka interaction check
karna. • Big Bang: Sab ek saath integrate karo • Top-Down: High-level modules pehle, stubs use
karo • Bottom-Up: Low-level modules pehle, drivers use karo • Sandwich/Hybrid: Dono combined

3. Validation Testing = Software customer ke requirements se match karta hai ya nahi check
karna. Alpha + Beta testing included.

4. System Testing = Complete integrated system ko test karna — functional aur non-functional
requirements dono. Includes: performance testing, security testing, stress testing.

Black-Box vs White-Box Testing:

Basis Black-Box Testing White-Box Testing

Internal code Nahi — code nahi dekhte Haan — code dekhke test
knowledge

Focus Input-Output behavior Internal logic, paths, branches

Also called Functional/Behavioral testing Structural/Glass-box testing

Done by Tester (non-developer) Developer

Techniques Equivalence partitioning, Boundary Statement coverage, Branch coverage,

value analysis Path testing

Level System, Acceptance testing Unit, Integration testing

Advantage Unbiased — user perspective se Thorough — internal bugs pakad sakta

dekhta hai hai

White-Box Testing Techniques:

• Statement Coverage: Har statement kam se kam ek baar execute ho
• Branch Coverage: Har if-else branch cover ho (true + false dono)
• Path Coverage: Saare possible paths execute hon
• Condition Coverage: Har condition ka true/false dono test ho

Black-Box Testing Techniques:

• Equivalence Partitioning: Input ko valid/invalid groups mein divide karo
• Boundary Value Analysis: Boundary pe values test karo (min, max, min-1, max+1)
• Decision Table Testing: Different conditions ka combination test karo
• State Transition Testing: System states test karo
Exam Gold: Black box = 'What it does' | White box = 'How it does it'. Order: Unit → Integration →
Validation → System
 UNIT IV: Software Reliability, Maintenance & Reengineering

Chapter 1: Software Reliability

Software Reliability = Software ka specified environment mein specified time period ke liye
correctly perform karne ki probability. Simply: 'Software kitna trustworthy hai?'

Measures of Reliability:

Metric Full Form Matlab Better value

MTTF Mean Time to Failure Average time between Zyada = better

failures

MTTR Mean Time to Repair Failure fix karne mein Kam = better
average time

MTBF Mean Time Between Failures MTTF + MTTR Zyada = better

Failure Rate Failures per unit time Per unit time mein kitni Kam = better
(λ) failures

Availability = System kitne time available rehta hai. Availability = MTTF / (MTTF + MTTR) × 100%
Example: 99.9% availability = 'Three nines' = ~8.76 hours downtime per year

Risk Management

Risk = Future mein hone wali ek uncertain event jo project ko negatively affect kar sakti hai. Risk
Exposure = Probability × Impact

Types of Risks:

Risk Type Matlab Example

Project Risks Budget, schedule, resources Team member resign kar gaya
affect

Product Risks Software quality aur performance New algorithm kaam nahi karta

Business Risks Business viability affect Competitor ne better product

launch kiya

Technical Risks Technology uncertainty New technology experience nahi

hai

Risk Management Process:

• 1. Risk Identification: Possible risks list karo (brainstorming, checklists)
• 2. Risk Analysis: Har risk ka probability aur impact estimate karo
• 3. Risk Prioritization: Risk Exposure = P × I se rank karo
 • 4. Risk Planning: Strategies plan karo
• 5. Risk Monitoring: Continuously monitor karo throughout project

Risk Strategies:

Strategy Matlab When to use

Avoidance Risk ko avoid karo — approach High probability, high impact

change karo

Mitigation Risk ka impact ya probability Moderate risk

reduce karo

Acceptance Risk accept karo — contingency Low impact risk

plan banao

Transfer Risk doosre ko transfer karo — Third party better handle kar sake
insurance, outsource

Software Safety

Software Safety = Software ensure kare ki woh hazardous situations create na kare jo harm ya
damage cause karein — especially safety-critical systems mein. Examples: Aircraft, Nuclear
plants, Medical devices, Automotive systems.

Chapter 2: Software Maintenance

Software Maintenance = Software deliver hone ke BAAD usmein changes karna. Software
lifecycle ka sabse lamba aur costly phase — typically 60-80% of total lifecycle cost!

Types of Software Maintenance:

Type Matlab Example Frequen
cy

Corrective Bugs/errors fix karna Crash fix, wrong calculation 20%

correct karna

Adaptive New environment mein New OS ke liye update 25%

work karne ke liye change

Perfective Performance ya features Speed optimize, new feature 50%

improve karna add

Preventive Future problems avoid Code refactoring, docs 5%

karne ke liye proactive update
changes

Software Supportability = Software kitni aasani se support kiya ja sakta hai — maintain, operate,
aur enhance karna kitna easy hai.
Chapter 3: Reengineering & Related Concepts

Software Reengineering = Existing software ko analyze karna, restructure karna aur reconstruct
karna — better quality, maintainability aur functionality ke saath. Old software ko modern banana
without complete rewrite.

Reengineering Process Steps:

• Inventory Analysis: Available software ki list banao — kaun sa reengineer karna hai?
• Document restructuring: Documentation update karo
• Reverse Engineering: Old code se design/requirements recover karo
• Code restructuring: Code improve karo without changing functionality
• Data restructuring: Data models improve karo
• Forward Engineering: New improved system build karo

Reverse Engineering vs Restructuring vs Forward Engineering:

Concept Direction Matlab Goal

Reverse Code → Design → Existing code se design aur System ko

Engineering Requirements requirements recover karna samajhna

Restructuring Old code → Better code Code improve karna — same Better quality
(same level) functionality, better quality code
(refactoring)

Forward Requirements → Design Normal development — New/improved

Engineering → Code requirements se final product system
banana

Exam Tip: Reverse = Code se Design nikalna (backward). Forward = Requirements se Code
banana (forward). Restructuring = Same level par improve karna (refactoring).

QUICK REVISION — ALL UNITS KEY POINTS

Unit I:
• SRS = 'Contract between client and developer'
• Waterfall = Linear sequential, no going back
• Spiral = Risk-driven by Barry Boehm
• Agile 4 values: Individuals, Working Software, Customer collaboration, Responding to Change
• Scrum = Most popular Agile framework

Unit II:
• COCOMO = Boehm ka model, LOC based, E = a × (KLOC)^b
• PERT formula: te = (O + 4M + P) / 6
• Verification = 'Building product right?' | Validation = 'Building right product?'
• Inspection = Formal defect detection BEFORE testing
• Milestone = Phase complete hone ka marker
Unit III:
• High Cohesion + Low Coupling = Best module design
• Black-box = No code knowledge | White-box = Code knowledge
• Testing order: Unit → Integration → Validation → System
• Boundary Value Analysis = Black-box technique
• Path/Statement/Branch Coverage = White-box techniques

Unit IV:
• MTBF = MTTF + MTTR
• Availability = MTTF / (MTTF + MTTR) × 100%
• 4 Maintenance types: Corrective (20%), Adaptive (25%), Perfective (50%), Preventive (5%)
• Reverse Engineering = Code → Design (backward direction)
• Reengineering = Old software ko modern banana without complete rewrite

Paper Strategy: 20-mark = Introduction + Definition + Diagram/Types + Examples +

Advantages/Disadvantages. 10-mark = Definition + Types + 2-3 points detail. 2-mark = 2-3 lines
definition only!