SPM Unit-2 Notes
SPM Unit-2 Notes
SOFTWARE PROJECT
MANAGEMENT
UNIT – 2
rk
A
Software Process Models &
Estimation Techniques
ic
em
Topics Covered:
• Project Life Cycle & Software Process Models
• Waterfall, Incremental, Spiral, RAD & Prototyping
• Agile Methods, DSDM, Extreme Programming
ad
AcademicArk
Downloaded by Rahul • AcademicArk • 05 May 2026 Visit: [Link]
BOE-068 | Software Project Management
Unit – 2 AcademicArk
Table of Contents
Contents
1 Project Life Cycle and Effort Estimation 4
1.1 Phases of the Software Project Life Cycle . . . . . . . . . . . . . . . . . . . 4
1.2 Relationship Between Project Life Cycle and Effort Estimation . . . . . . . 4
2 Software Process 6
2.1 Definition of Software Process . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2 Importance of Software Process . . . . . . . . . . . . . . . . . . . . . . . . 6
rk
3 Software Process Models 8
3.1 1. Waterfall Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.1.1 Characteristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.1.2 Advantages . . .
3.1.3 Disadvantages . .
A
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
.
.
.
.
.
.
.
.
8
8
3.1.4 Best Suited For .
ic
. . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 2. Incremental Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.1 Characteristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
em
3.2.2 Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.3 Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.4 Best Suited For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 3. Spiral Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3.1 Characteristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
ad
3.3.2 Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3.3 Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3.4 Best Suited For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 4. Prototyping Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Ac
6 Agile Methods 18
6.1 Agile Principles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.2 Characteristics of Agile Development . . . . . . . . . . . . . . . . . . . . . 18
6.3 Agile Lifecycle Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
rk
8.4 Advantages of XP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
8.5 Challenges of XP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
A
9.1 Challenges in Managing Interactive Processes . . . . . . . . . . . . . . . . 26
9.2 Management Strategies for Interactive Processes . . . . . . . . . . . . . . . 27
ic
10 Basics of Software Estimation 29
10.1 Need for Estimation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
em
10.2 Types of Estimation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
10.3 Estimation Accuracy vs. Project Phase . . . . . . . . . . . . . . . . . . . . 30
11.1.1 Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
11.1.2 Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
11.1.3 Disadvantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
11.1.4 Best Used For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Ac
13 COCOMO II 37
13.1 Overview of COCOMO II . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
13.2 COCOMO II Sub-Models . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
13.2.1 1. Composition Model (Early Project Stage) . . . . . . . . . . . . . 37
13.2.2 2. Application Composition Model (RAD Development) . . . . . . 37
13.2.3 3. Post-Architecture Model (Full Development) . . . . . . . . . . . 37
13.3 COCOMO II Effort Estimation Formula . . . . . . . . . . . . . . . . . . . 38
13.4 COCOMO II Cost Drivers (Effort Multipliers) . . . . . . . . . . . . . . . . 38
13.4.1 Key Cost Drivers and Multiplier Values . . . . . . . . . . . . . . . . 38
13.5 Example – COCOMO II Calculation . . . . . . . . . . . . . . . . . . . . . 40
rk
13.6 Advantages of COCOMO II . . . . . . . . . . . . . . . . . . . . . . . . . . 40
13.7 Limitations of COCOMO II . . . . . . . . . . . . . . . . . . . . . . . . . . 40
A
14 Parametric Productivity Model 42
14.1 Concept of Parametric Models . . . . . . . . . . . . . . . . . . . . . . . . . 42
14.2 Parametric Estimation Process . . . . . . . . . . . . . . . . . . . . . . . . 42
14.3 Role in Effort Estimation . . . . . .
ic
. . . . . . . . . . . . . . . . . . . . . . 42
14.4 Example – Parametric Productivity Model . . . . . . . . . . . . . . . . . . 43
14.5 Advantages and Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . 43
em
14.5.1 Advantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
14.5.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
rk
Feasibility study Gather & analyze Architecture & Coding & unit System testing
Charter requirements design docs testing UAT
• Development Phase: Actual effort tracked against estimate; variances identified and
corrected.
• Testing Phase: Test effort estimated separately; often 20–40% of total project effort.
• Deployment Phase: Effort for installation, configuration, user training, cutover
planning.
E REAL-WORLD EXAMPLE
Example – E-commerce Portal Project:
• Concept: ROM estimate 12–18 months (±50% accuracy).
• Requirements: Refined to 14 months, 15 developers, Rs. 1.2 crores.
• Design: Baseline finalized as 14 months with detailed task breakdown (WBS).
• Development: Actual effort 15.2 months (8% variance – acceptable).
• Testing: Effort = 3.5 months (25% of project effort) – payment gateway bugs
delayed by 2 weeks.
• Deployment: 2 weeks for data migration and user training.
rk
A
ic
em
ad
Ac
2. Software Process
D DEFINITION
A Software Process is a set of activities, methods, practices, and transformations
that people employ to develop and maintain software and associated products (e.g.,
project plans, designs, code, test cases, user manuals). It describes how software is
built, not what is built.
rk
reviews, automated testing).
• Practices: Guidelines and standards (code naming conventions, documentation tem-
A
plates, peer review checklists).
• Roles: Individuals involved (developer, tester, architect, project manager).
ic
• Control Flow: The sequence and dependencies among activities (which activity must
complete before another starts).
em
risk management.
• Traceability: Clear documentation of decisions and artifacts enables traceability from
requirements to code to tests.
• Repeatability: Processes can be replicated across multiple projects, teams, and
organizations.
• Quality Assurance: Built-in review and testing checkpoints catch defects early.
• Risk Mitigation: Structured risk management and monitoring activities reduce
project failures.
• Team Alignment: Clear processes ensure all team members understand their roles
and responsibilities.
• Customer Confidence: Documented processes demonstrate professionalism and
competence to clients.
E REAL-WORLD EXAMPLE
Example – Healthcare Software Development: A hospital’s electronic health
records (EHR) system must follow strict FDA and HIPAA regulations. A well-defined
software process ensures: (1) Requirements traceability for regulatory audits, (2)
Design reviews for patient safety, (3) Code reviews for security vulnerabilities, (4)
Comprehensive testing including edge cases, (5) Change control to prevent unauthorized
modifications, (6) Documentation for compliance. Without a solid process, the hospital
risks system failures affecting patient care or data breaches violating patient privacy.
rk
A
ic
em
ad
Ac
Complete system
Design Rare
architecture
rk
Code all modules
Implementation in sequence
A
System testing,
Testing UAT
ic
Production
Deployment release
em
Bug fixes,
Maintenance enhancements
3.1.1. Characteristics
ad
• Linear and Sequential: Each phase completes before the next begins; no overlap.
• Document-Driven: Heavy emphasis on documentation at each phase.
Ac
3.1.2. Advantages
• Clear structure; easy for managers to understand and track progress.
• Good for projects with well-understood, stable requirements.
• Extensive documentation aids knowledge transfer and maintenance.
• Works well with geographically distributed teams (document-based handoffs).
3.1.3. Disadvantages
• Inflexible: Cannot easily accommodate requirement changes.
• Integration risk: Modules integrated only near the end; integration problems discov-
ered late.
rk
Test 1 Test 2 Test 3
3.2.2. Advantages
• Early and frequent delivery of working software.
Ac
3.2.3. Disadvantages
• Requires careful planning to partition requirements into increments.
• Integration complexity if increments have dependencies.
• Difficult to apply to systems where all features must be available initially.
Evaluation Engineering
Prototype review Build & test
Iter 3
Iter 4
Risk
Iter 2
Iter 1
Planning Risk
Objectives, Analysis
rk
constraints Risks & mitigation
Figure 4: Spiral Model – Risk-driven iterative approach with 4 quadrants per spiral.
A
3.3.1. Characteristics
• Combines elements of Waterfall and Incremental models.
ic
• Each spiral cycle consists of 4 quadrants: Planning, Risk Analysis, Engineering, and
Evaluation.
em
3.3.2. Advantages
• Excellent risk management; risks identified and mitigated early.
Ac
3.3.3. Disadvantages
• Spiral management is complex; requires experienced practitioners.
• Difficult to predict project schedule and cost in advance.
• Not suitable for small, low-risk projects (overhead not justified).
rk
4. Refinement: Modify prototype based on feedback.
5. Repeat: Steps 2–4 may repeat multiple times until requirements are sufficiently
refined.
A
6. Full Development: Once requirements are stable, develop the complete system using
a traditional methodology.
ic
3.4.2. Advantages
• Reduces requirement ambiguity through tangible prototypes.
em
3.4.3. Disadvantages
ad
• Prototype development cost; may be discarded or become basis for suboptimal final
system.
Ac
E REAL-WORLD EXAMPLE
Example – Mobile Banking App UI Prototyping: A bank’s development team
builds a clickable prototype of a mobile banking app using Figma or Adobe XD,
focusing on login, fund transfer, and bill payment screens. Users (customers and bank
employees) review the prototype and suggest changes: “Move the logout button to the
top-right corner” or “Use biometric login for faster authentication.” After 3 iterations
of feedback and refinement, the prototype is approved. The development team then
uses it as the design specification for full-scale development in React Native.
rk
tation
Best For Fixed scope Evolving High risk UI/UX
features refinement
A
ic
em
ad
Ac
rk
– Large projects (20+ developers): Spiral, RUP (Rational Unified Process), Waterfall
with governance.
• Requirements Clarity:
A
ic
– Partially known: Incremental, Spiral.
– Uncertain or volatile: Agile, Prototyping.
em
• Risk Level:
• Technology Novelty:
Ac
• User Involvement:
• Time-to-Market Pressure:
• Regulatory Compliance:
• Team Experience:
• Geographical Distribution:
rk
– Distributed team: Waterfall or Incremental (document-based communication).
A
Risk Level Size
Waterfall High
ic Low Any
E REAL-WORLD EXAMPLE
ad
2. Mobile Banking App: Spiral (high security risk, evolving requirements, need
for user feedback on UX).
3. Startup MVP: Agile (uncertain requirements, fast time-to-market, small co-
located team).
4. ERP System for Large Enterprise: Incremental or RUP (complex system,
can be broken into modules, phased deployment across departments).
5. Social Media Platform: Agile (rapidly evolving features, frequent releases, user
feedback-driven, scalability as secondary concern initially).
rk
• Reusable Components: Leverage pre-built business components, frameworks, and
libraries.
A
• Minimal Planning: Focus on quick prototypes rather than exhaustive upfront design.
• User Involvement: Users/clients actively participate in reviews and feedback at each
timebox end.
ic
• Iterative Refinement: Each cycle delivers working software with refined features.
em
• Testing & Turnover: QA tests, client performs UAT. Refinements made based on
feedback. Deliverable: Tested, signed-off application.
• Deployment & Support: Install in production, provide user training and support.
Deliverable: Live system.
rk
validation.
• Flexibility: Changes can be incorporated in the next timebox.
A
• Lower Rework: Early and frequent testing catches defects quickly.
5.3.2. Limitations
ic
• Requires Active User Involvement: High user participation demand; not always
feasible.
em
• Team Expertise: RAD tool expertise is essential; learning curve for traditional
developers.
• Scalability: RAD-generated code may not be as optimized or maintainable as hand-
crafted code.
ad
E REAL-WORLD EXAMPLE
Example – RAD for CRM System: A company needs a Customer Relation-
ship Management (CRM) system quickly. Using a RAD platform (e.g., Microsoft
PowerApps, Salesforce Customization):
• Week 1: Business analysts interview sales and support teams to understand
processes.
• Week 2: Data model created (Customers, Contacts, Opportunities, Activities).
• Week 3: Process workflows defined (lead creation, deal progression, customer
communication).
• Week 4: RAD tool auto-generates screens, forms, dashboards from the model.
• Week 5: Sales team tests prototype; requests “Add Notes field to Contact.”
• Week 6: Developer adds Notes field; system regenerated.
rk
A
ic
em
ad
Ac
6. Agile Methods
D DEFINITION
Agile Methods are a family of iterative, incremental software development approaches
that emphasize:
• Responding to change over following a plan.
• Individuals and interactions over processes and tools.
• Working software over comprehensive documentation.
• Customer collaboration over contract negotiation.
Based on the Agile Manifesto (2001), Agile is a mindset and culture, not just a set
of practices.
rk
The Agile Manifesto is built on 12 core principles:
A
• Change Acceptance: Welcome changing requirements, even late in development.
ic
• Frequent Delivery: Release working software every 1–4 weeks (sprints).
• Collaboration: Business and development teams work together daily.
em
team.
• Working Software: Primary measure of progress is working, tested software.
• Sustainable Pace: Maintain a constant, sustainable pace throughout the project.
Ac
• User Stories: Requirements expressed as user stories (e.g., “As a user, I want to reset
my password so that I can regain access.”).
• Continuous Feedback: Product backlog prioritized and refined based on user feed-
back.
• Adaptive Planning: Plans are continuously adjusted based on actual progress and
changing requirements.
• Minimal Documentation: Documentation is created as needed; working software is
the primary output.
• Daily Collaboration: Daily standup meetings (15 minutes) ensure team alignment.
• Test-Driven Development: Tests written before code; automated testing throughout.
• Continuous Integration: Code changes integrated multiple times per day; automated
rk
build and test.
• Retrospectives: Teams reflect on what went well and what to improve after each
sprint.
E REAL-WORLD EXAMPLE
Example – Agile Development of Mobile Fitness App:
• Product Backlog: User registration, workout logging, progress charts, social
sharing, push notifications.
• Sprint 1 (2 weeks): Implement user registration and login. Daily standups
ensure developers align. Review at end: “Successfully implemented OAuth login.”
Feedback: “Add fingerprint authentication for mobile.” (Added to backlog).
• Sprint 2 (2 weeks): Implement workout logging and progress charts. Retrospec-
tive: “We spent too much time on chart UI. Next time, use existing library.”
• Sprint 3 (2 weeks): Social sharing and push notifications.
• After 3 sprints (6 weeks): MVP released to beta users for feedback.
• Sprint 4: Based on user feedback, prioritize features and continue development.
This approach delivers value incrementally, enables rapid course correction, and keeps
the team motivated with visible progress.
rk
A
ic
em
ad
Ac
rk
• People-Centric: Focus on skilled, motivated teams.
• Iterative and Incremental: Deliver working software in short cycles.
A
• Business-Focused: Align with business objectives; deliver business value early.
ic
• Governance: Formal controls and reviews (unlike pure Agile).
• MoSCoW Prioritization: Must have, Should have, Could have, Won’t have.
em
Refinement
3. 4. 5.
ad
1. 2. 6.
Business Functional Design
Pre-Project Feasibility Impl.
Study Model Build
rk
• Flexible Scope: Can adjust scope within timeboxes; less scope creep.
• Reduced Rework: Frequent prototyping catches design flaws early.
A
• User Involvement: Active participation in iterations ensures alignment with user
needs.
E REAL-WORLD EXAMPLE
ic
Example – DSDM for Bank’s Internet Banking Portal:
em
• Pre-Project: Bank CIO approves project; business case shows 15% reduction in
branch traffic.
• Feasibility: Technology stack ([Link], React, PostgreSQL) deemed feasible;
security requirements identified.
• Business Study: Analyze customer journey for account viewing, fund transfer,
ad
search.”
– Iteration 2: Add search; new feedback: “Show investment portfolio value.”
– Iteration 3: Investment portfolio added; approved for next phase.
• Design & Build (Week 9–20):
– Sprint 1: Implement authentication and account viewer.
– Sprint 2: Fund transfer with approval workflow.
– Sprint 3: Payment processing integration with RBI-certified gateway.
– User acceptance testing after Sprint 3.
• Implementation: Soft launch to 1000 customers; monitor for issues; full rollout
after 2 weeks.
• Total Timeline: 6 months vs. 12 months with Waterfall.
rk
• Feedback: Continuous feedback from tests, customer, and team; short feedback loops.
• Courage: Make aggressive changes; refactor code without fear; throw away code if
A
needed.
• Respect: Mutual respect among team members; confidence in each other’s abilities.
ic
8.2. Practices of XP
• Pair Programming: Two developers share one workstation; one writes code, the
em
other reviews and provides real-time feedback. Reduces defects, spreads knowledge.
• Test-Driven Development (TDD): Write automated test cases before writing code.
Process: Red (test fails) → Green (code passes test) → Refactor (improve code).
ad
• Continuous Integration: Code changes integrated multiple times per day (ideally
every few hours). Automated build and test runs after each integration. Catches
integration issues early.
Ac
system’s behavior.
Figure 8: Extreme Programming Workflow – TDD cycle integrated with pair programming and CI.
rk
8.4. Advantages of XP
• High Quality: TDD and pair programming drastically reduce defects (up to 50%
A
fewer bugs reported).
• Flexibility: Refactoring and simple design make code easy to modify; requirements
ic
changes manageable.
• Knowledge Sharing: Pair programming and collective ownership ensure knowledge
em
• Team Morale: Pair programming reduces isolation; continuous delivery gives team
visibility and satisfaction.
8.5. Challenges of XP
Ac
• Cost: Pair programming doubles labor cost in the short term (though quality gains
may offset this).
• Learning Curve: Team must learn TDD, refactoring, and CI practices; productivity
initially decreases.
• Infrastructure: Requires automated testing framework, CI/CD tools, build servers.
• Team Stability: Works best with stable, co-located teams; difficult with high turnover
or remote work.
• Scalability: Designed for small teams (5–10); unclear how to scale XP to large
projects.
E REAL-WORLD EXAMPLE
Example – XP for Financial Trading Engine:
• Requirements: Build a low-latency trading system to execute stock orders within
10 milliseconds.
• Pair Programming: Junior developer and experienced developer work on critical
trading logic together, catching edge cases in real time.
• TDD Approach:
– Test 1: “Order placed with insufficient funds should be rejected.” Write test;
fails.
– Write code to reject order; test passes.
– Test 2: “Multiple orders should not execute in parallel (concurrency issue).”
Write test; fails.
– Write thread-safe code; test passes.
rk
• Continuous Integration: Every 2 hours, code merged to mainline; automated
tests run; latency benchmarks measured. If latency degraded, developers refactor
immediately.
A
• Refactoring: After release, team refactors critical path from 12ms to 8ms latency;
no new features added, but quality improved.
ic
• Result: Extremely reliable trading engine with <5 critical bugs found in production
over 2 years vs. 50+ bugs in previous iteration.
em
ad
Ac
rk
changes.
A
– Mitigation: Use velocity-based planning (measure avg. story points completed
per sprint); three-point estimation.
ic
• Customer Availability: Agile requires continuous customer involvement (product
owner, review meetings), which busy customers can’t always provide.
em
• Quality Regression: Early iterations may prioritize speed over quality; technical
debt accumulates.
– Maintain a prioritized, groomed backlog (top 2–3 sprints well-defined, future items
rough estimates).
– Regularly refine estimates as understanding improves.
– Remove or defer low-value items to prevent scope creep.
• Velocity Tracking:
rk
– Measure story points completed per sprint (velocity).
– Use historical velocity to predict how many story points can fit in future sprints.
A
– Example: If velocity is 40 points/sprint and the backlog has 400 points, estimate
10 sprints (5 months) to completion.
ic
• Burn-Down Charts:
em
– Visual representation of work remaining vs. time in a sprint.
– X-axis: Sprint days; Y-axis: Story points remaining.
– If burn-down line is above the ideal line, team is behind; accelerate or reduce scope.
ad
• Retrospectives:
– At the end of each sprint, team reflects: What went well? What could improve?
What will we commit to next sprint?
Ac
• Communication Protocols:
– Daily standup (15 min): Each team member: (1) What did I do? (2) What will I
do? (3) Any blockers?
– Weekly demo: Show working features to stakeholders; gather feedback.
– Sprint planning: Team estimates and commits to upcoming sprint’s work.
• Risk Management:
– In iterative processes, risks are identified early (first few sprints); mitigation strate-
gies implemented.
– Example: If architectural risk identified in Sprint 1, allocate Sprint 2 to proof-of-
concept; mitigate before scaling.
– Track key metrics: velocity, burn-down rate, defect density, deployment frequency.
– Make metrics visible to team and stakeholders (dashboard); data-driven decisions.
E REAL-WORLD EXAMPLE
Example – Managing Scrum for Enterprise ERP Rollout:
• Challenge: Large enterprise ERP project (200+ story points total) spanning 6
months; distributed team across Bangalore, Singapore, US.
• Strategies Applied:
– Velocity Tracking: Sprint 1 velocity = 35 points. Sprint 2 = 38 points.
Stabilized at 40 points/sprint.
– Burn-Down Management: Sprint 4 behind schedule; Scrum Master identi-
rk
fied: “Payment gateway integration delayed.” Team decided to defer less critical
reports to Sprint 5.
– Asynchronous Standups: Teams in different zones post 5-min video updates
A
in Slack instead of live 3am calls.
– Retrospectives: Sprint 3 retro identified: “Integration tests take 8 hours;
slows down CI.” Action: Parallelize test execution; reduced to 2 hours in Sprint
ic
4.
– Metrics Dashboard: Stakeholders see real-time velocity, burn-down, defect
em
counts; confidence in project health increased.
• Outcome: Project delivered in 6 months (on time); 98% of original scope completed
(2% deferred with business agreement).
ad
Ac
rk
• Budget Planning: Set budget baselines; identify cost risks.
• Schedule Planning: Estimate project duration; identify critical path; plan milestones.
A
• Risk Assessment: Understand estimation uncertainty; prepare contingencies.
• Change Impact Analysis: When requirements change, estimate impact on effort
ic
and schedule.
• Performance Tracking: Actual vs. estimated effort reveals productivity trends;
em
– Example: “This project will take 6 calendar months with 2 developers” (12 PM / 2
devs = 6 months).
• Baseline Estimate: Final estimate, ±10% accuracy. Done at end of planning; used
for tracking.
High
rk
±3%
±5%
A
Medium ±10% ic
±20%
Low
em
±50%
0% Project Phase
Concept Planning Design Development Testing
ad
Figure 9: Estimation accuracy vs. project phase. Early estimates are rough; later estimates are more
precise.
Ac
rk
knowledge.
11.1.1. Process
A
1. Identify 2–3 experts with experience in similar projects.
2. Present project requirements and scope.
ic
3. Each expert independently provides their estimate.
em
4. Discuss estimates; resolve disagreements.
5. Aggregate estimates (often using median or average).
11.1.2. Advantages
• Quick; doesn’t require formal data collection.
ad
11.1.3. Disadvantages
• Subjective; prone to bias (overoptimism, anchoring).
• Accuracy depends on expert’s experience; outdated experts may miss new technologies.
• Lacks scientific rigor; hard to explain or justify estimates.
11.2.1. Process
1. Identify a historical project similar in scope, technology, and complexity.
2. Note the actual effort and cost of the historical project.
3. Identify differences between historical and current project (size, complexity, team
experience).
4. Adjust historical effort based on differences.
rk
5. Formula: Estimated Effort = Historical Effort × Adjustment Factors
11.2.2. Example
A
• Historical Project: Web portal for 50 users took 12 months with 6 developers = 72
person-months.
ic
• Current Project: Web portal for 500 users (10× larger user base).
• Adjustment: Database size 10× larger (2× complexity), but reusing framework (0.8×
em
factor).
• Estimated Effort: 72 × 10 × 2 × 0.8 = 1152 person-months (unrealistic; need to
reconsider approach or split into phases).
11.2.3. Advantages
ad
11.2.4. Disadvantages
• Requires good historical data repository (many organizations lack this).
• Similar projects are hard to find; projects always differ in some way.
• Adjustment factors are subjective.
Effort = a × (Size)b ×
Y
(Adjustment Factors)
Where:
11.3.2. Advantages
• Objective, repeatable, scientific.
• Transparently documented; easy to explain and justify.
rk
• Incorporates multiple factors (size, complexity, environment).
• Can be validated against historical data.
11.3.3. Disadvantages
A
• Requires calibration with historical data; new organizations may lack data.
ic
• Models assume certain project characteristics; may not apply to novel project types.
em
• Garbage in, garbage out: if size estimates are wrong, effort estimates are wrong.
E REAL-WORLD EXAMPLE
Example – Combining Three Estimation Techniques for Validation:
A software company is asked to estimate effort for a new financial analytics application
Ac
(estimated at 50 KLOC).
1. Expert Judgment: Three analysts estimate 18, 20, 22 months → Median = 20
months.
2. Estimation by Analogy: Similar financial app 2 years ago was 40 KLOC, took
16 months. Scale factor = (50/40)1.2 (accounting for complexity) = 1.32. Adjusted
estimate: 16 × 1.32 = 21 months.
3. COCOMO II: Effort = 2.94 × (50)1.0 × 1.08 (moderate complexity) ×1.1 (new
team) = 2.94 × 50 × 1.1 × 1.08 = 174 person-months → 174/10 = 17.4 months.
Results: Expert = 20 months; Analogy = 21 months; COCOMO II = 17.4 months.
Average = 19.5 months. The PM proposes a baseline of 20 months. The range (17–21
months) provides a confidence band for stakeholders.
rk
analysis, and benchmarking.
• Basis: Software functionality is characterized by the data it processes (data movements,
transformations, storage).
A
• Universality: Applicable to all software types (business, real-time, embedded, scien-
tific).
ic
• Granularity: Can measure at project level or individual requirement level.
em
• Entry (E): User or external system provides data to the software (e.g., “Login button
clicked”, “API request received”).
ad
• Exit (X): Software provides data to user or external system (e.g., “Display user
dashboard”, “Send email notification”).
Ac
• Read (R): Software reads data from persistent storage (database, file).
rk
12.3. Applications of COSMIC
• Effort Estimation: Correlate COSMIC FP with effort from historical projects.
A
– Example: If historical data shows 1 COSMIC FP = 0.5 person-days, then 8 COSMIC
FP = 4 person-days for login feature.
ic
• Productivity Analysis: Measure output (COSMIC FP) per person-day; benchmark
against industry.
em
• Scope Validation: COSMIC identifies all data movements; ensures requirements are
complete.
• Quality Assessment: High COSMIC per unit effort might indicate quality issues;
ad
12.4.1. Advantages
• Universal: Applicable to all software types (unlike FPA which is business-focused).
• Objective: Based on data movements, not technology; independent of implementation.
• Decomposable: Can measure at feature level or system level; flexible granularity.
• Tool Support: Automated COSMIC measurement tools available.
12.4.2. Limitations
• Learning Curve: Requires training to properly identify data movements and com-
plexity.
• Subjectivity: Determining complexity factor and boundary of “a requirement” involves
judgment.
• Not Applicable to All Domains: Less effective for algorithmic or UI-heavy systems
E REAL-WORLD EXAMPLE
Example – COSMIC Measurement of E-Commerce Checkout
Requirement: Process Payment
• Entry: User clicks “Pay Now”; cart data sent. E = 1
• Read: Retrieve payment gateway API URL from config; fetch customer discount
rules. R = 2
• Transformation: Validate card number (Luhn algorithm); apply discount; calculate
tax. Complexity = 2 (multiple validations).
• Write: Save transaction record to database; update inventory. W = 2
rk
• Exit: Display payment confirmation; send confirmation email. X = 2
COSMIC Size = (1 + 2 + 2 + 2) × 2 = 14 COSMIC FP
Estimation: Assume 1 COSMIC FP = 0.75 person-hours (based on historical data).
A
Effort = 14 × 0.75 = 10.5 hours for checkout feature.
ic
em
ad
Ac
13. COCOMO II
D DEFINITION
COCOMO II (Constructive Cost Model Version 2) is an advanced algorithmic effort
estimation model developed at USC by Barry Boehm. It estimates software project
effort and schedule based on software size and a set of cost drivers (factors affecting
productivity).
COCOMO II is an update to the original COCOMO model (1981), tailored for modern
software development practices (OOP, COTS, agile).
rk
• Size-Based: Effort is primarily a function of software size (measured in KLOC or
Function Points).
• Cost Driver Adjustments: Effort is multiplied by factors representing team experi-
A
ence, development environment, technology risk, etc.
• Empirical: Derived from analysis of 100+ actual software projects; continuously
ic
updated with new data.
• Scalable: Works for small (<5 KLOC) to very large (> 1000 KLOC) projects.
em
• Used during concept and requirement phase when detailed architecture not yet defined.
• Assumes COTS components available; integration effort primary concern.
Ac
• Takes into account all cost drivers (team experience, development environment, risk,
etc.).
• Formula: (described in detail below).
Where:
rk
• B = Exponential constant (typically 1.0–1.2) accounting for economies/diseconomies
of scale.
• EMi = Effort Multipliers (cost drivers).
A
13.4. COCOMO II Cost Drivers (Effort Multipliers)
ic
Cost drivers are categorized into four groups:
em
1. Product Factors
Size, Complex-
ity, Reliability
2. Platform Factors
Constraints, De-
velopment Env.
ad
3. People Factors
Experience, Capability
4. Process Factors
Methodology,
Ac
Tools, Quality
S SUMMARY TABLE
rk
Analyst Capabil- 1.42 1.0 0.71
ity
Programmer Ca- 1.42 1.0 0.71
pability
Team Experi- 1.29 1.0
A
0.85
ic
ence
rity
Use of Tools 1.17 1.0 0.90
Interpretation:
ad
• Example: High analyst capability (0.71) = 29% less effort than nominal.
• Example: Very high complexity (1.40) = 40% more effort than nominal.
rk
Estimated Effort: 234.5 PM
With 10 developers: Duration = 234.5 / 10 = 23.5
months
Cost @ Rs. 5 lakh/PM = Rs. 117.25 crores
E REAL-WORLD EXAMPLE
Example – COCOMO II for Different Project Types:
• Small Internal Tool (10 KLOC): A = 2.94, B = 1.0. Effort = 2.94 × 10 × 1.0
(all nominal) = 29.4 PM. With 2 developers = 14.7 months.
• Medical Device Software (100 KLOC, High Reliability): Reliability multi-
plier = 1.40. Effort = 2.94 × 100 × 1.40 = 411.6 PM. With 10 developers = 41.2
months.
• E-Commerce Platform (200 KLOC, High Reuse): Reusability multiplier =
0.81. Effort = 2.94 × 200 × 0.81 = 476.8 PM. With 15 developers = 31.8 months.
rk
A
ic
em
ad
Ac
rk
• Primary Metric: Productivity = Size of Deliverable / Effort Expended
A
• Inverse Relationship: Productivity and Effort are inversely related.
1. Historical Data Collection: Gather data from past projects: size (KLOC or FP),
effort (PM), productivity (size/effort).
Ac
rk
A 20 40 0.50 Java Low
B 50 75 0.67 Java Medium
C 30 40 0.75 C# Medium
D
E
60
40
80
50
0.75
0.80
A C#
Python
High
High
ic
Analysis:
• Project: Mobile app, 25 KLOC, Team has Python experience, high maturity.
• Expected Productivity: Similar to Project E (0.80 KLOC/PM).
Ac
14.5.2. Limitations
• Historical Data Dependency: Requires substantial historical project data (10+
projects minimum); new organizations may lack this.
• Context Variability: Productivity factors may vary across domains, technologies,
and team compositions; hard to generalize.
• Statistical Expertise Needed: Building and interpreting regression models requires
statistical knowledge.
• Changing Environment: Productivity models become outdated as technology, tools,
and processes evolve.
rk
A
ic
em
ad
Ac
K KEY POINTS
Essential Definitions to Memorise:
• Software Process: Set of activities, methods, practices to develop and maintain
software.
• Waterfall: Linear, sequential phases; document-driven; inflexible to change.
• Incremental: Build in cycles; each increment delivers partial functionality; user
involved throughout.
• Spiral: Risk-driven iterative model with 4 quadrants per spiral (Planning, Risk
Analysis, Engineering, Evaluation).
• RAD: Rapid Application Development; timeboxed 60–90 day cycles; visual tools;
rk
COTS components.
• Agile: Iterative development, working software every 1–4 weeks, continuous
feedback, change acceptance.
A
• DSDM: Dynamic System Development Method; enterprise Agile with formal
governance.
ic
• XP: Extreme Programming; emphasis on technical practices (TDD, pair program-
ming, CI, refactoring).
• Software Estimation: Quantifying resources (time, effort, cost) required for
em
software development.
• COCOMO II: Effort = A × (KLOC)B × (EMi ) ; uses KLOC size as input.
Q
S SUMMARY TABLE
Unit–2 Process Models Quick Comparison:
Model Approach Testing Risk Flexibility
Mgmt
Waterfall Sequential Late Minimal Very Low
Incremental Iterative Each Inc. Good Medium
Spiral Risk-Driven Each Loop Excel- High
lent
RAD Timeboxed Continuous Good High
Agile Sprint- Continuous Good Very High
Based
XP Extreme TDD Good Very High
K KEY POINTS
rk
Estimation Techniques Comparison:
• Expert Judgment: Quick, intuitive, but subjective.
• Estimation by Analogy: Uses historical similar projects; adjustment-based.
•
•
A
Algorithmic (COCOMO II): Scientific, reproducible, needs KLOC input.
COSMIC: Functional size based on data movements; universal.
ic
• Parametric Productivity: Uses historical productivity to predict effort.
em
ad
Ac
A
Subject: BOE-068 | Software Project Management
University: Dr. A.P.J. Abdul Kalam Technical University (AKTU)
ic
Semester: [Link] 6th Semester | Academic Year: 2025–26
em
AcademicArk
Downloaded by Rahul • AcademicArk • 05 May 2026 Visit: [Link]