Rural Technology & Community Development (CS-604) - Unit 4 Short Notes

UNIT 4: Software Project Management

I. Software Economics

Definition & Importance

Software economics studies the financial aspects of software development—costs, benefits, ROI, and economic decision-making. It is crucial for project justification, budget allocation, and strategic alignment with business goals.

Evolution Over Time

Strategies for Enhancing Software Economics

• Reuse & Component-Based Development: Reduce redundant effort.

• Automation: CI/CD, testing, deployment to cut labor costs.

• Early Validation: Prototyping, user feedback to avoid costly rework.

• Outsourcing & Offshoring: Leverage lower-cost regions (with risk management).

• Open Source Adoption: Reduce licensing costs, accelerate development.

Important Trends

• Shift from effort-based to value-based economics.

• Cloud economics: Pay-as-you-go, scalability.

• DevOps economics: Reduced cycle time, higher deployment frequency.

• AI/ML augmentation: Automated code generation, testing.

Project Assessment Dimensions

1. Strategic Alignment: Does it support organizational goals?

2. Technical Viability: Feasibility with current tech stack & skills.

3. Economic Impact: NPV, ROI, payback period analysis.

Cost Estimating & Budgeting Improvement

• Methods: COCOMO (Constructive Cost Model), Function Points, Use Case Points.

• Improvement: Use historical data, parametric models, expert judgment, and bottom-up estimating for accuracy.

• Budgeting: Include contingency reserves (typically 10–20%), track via Earned Value Management (EVM).

Automation Through Software Environments

• Tools: Jenkins, GitLab CI, Docker, Kubernetes.

• Impact: Reduces manual effort, accelerates feedback loops, improves quality → better economics.

[!TIP]

Exam Focus: Evolution timeline, strategies, and automation’s role in cost reduction are frequent 7-mark questions. Use examples like CI/CD for automation.

II. Modern Software Management

Guiding Principles

1. Customer-centricity: Deliver value continuously.

2. Agility & Adaptability: Respond to change over following a plan.

3. Empowered Teams: Self-organizing, cross-functional teams.

4. Continuous Improvement: Retrospectives, process tweaks.

5. Quality Built-In: Shift-left testing, automation.

Core Principles Behind Modern Software Management

• Lean Thinking: Eliminate waste (e.g., unnecessary documentation).

• Systems Thinking: View development as an interconnected value stream.

• Data-Driven Decisions: Use metrics (lead time, deployment frequency).

• Collaboration Over Contract Negotiation: Stakeholder engagement.

Conventional vs. Modern Software Project Management

[!TIP]

Common Pitfall: Don’t just list differences—explain why modern approaches suit volatile, complex projects (e.g., internet-scale systems).

III. Software Lifecycle Phases

Overall Goal: Transform user needs into a reliable, maintainable software system through structured phases.

Phase Details

Why Systems Must Adapt or Lose Effectiveness

• Technological Change: New platforms, frameworks, security threats.

• User Needs Evolution: Market demands, regulatory updates.

• Business Environment Shifts: Competitive pressures, organizational strategy changes.

• Technical Debt Accumulation: Poor design decisions degrade maintainability.

• Integration Requirements: New systems/APIs emerge.

[!TIP]

Exam Tip: For “explain with examples,” pick a relatable system (e.g., e-commerce, hospital management) and walk through each phase contextually.

IV. Software Artifacts

Management Artifacts vs. Engineering Artifacts

Types of Artifacts in Software Development

1. Project Artifacts: Plans, schedules, contracts.

2. Process Artifacts: Process models, guidelines, templates.

3. Product Artifacts: Requirements, design, code, tests, manuals.

4. Supporting Artifacts: Meeting minutes, issue logs.

Pragmatics Artifacts (Context-Specific Notes)

• Informal, ad-hoc documents capturing tacit knowledge (e.g., whiteboard sketches, developer notes, “how-to” wikis).

• Importance: Bridge formal documentation gaps; useful for onboarding, troubleshooting.

• Risk: Can become outdated or lost if not managed.

V. Software Design & Architecture

Modular Design: Purpose & Importance

• Purpose: Decompose system into manageable, independent modules.

• Importance:

  • Manage Complexity: Easier to understand, develop, test.

  • Reusability: Modules can be reused across projects.

  • Maintainability: Isolate changes to specific modules.

  • Parallel Development: Teams can work on different modules.

Cohesion & Coupling in Modular Systems

Top-down vs. Bottom-up Design Approach

Model-Based Software Architecture

• Use of formal models (e.g., UML, SysML, architectural views) to represent structure, behavior, and composition.

• Benefits:

  • Communication tool for stakeholders.

  • Basis for analysis (performance, reliability).

  • Guide for implementation and maintenance.

• Example: 4+1 View Model (Logical, Development, Physical, Scenarios).

Programming Practices & Coding Standards: Significance

• Readability & Maintainability: Consistent style (naming, indentation).

• Reduced Defects: Standards prevent common errors (e.g., magic numbers).

• Team Collaboration: Common conventions ease code reviews.

• Tooling Support: Enables static analysis, automated formatting.

• Examples: PEP 8 (Python), Google Java Style Guide.

[!TIP]

Key Distinction: Cohesion is internal to a module; coupling is external between modules. High cohesion + low coupling = good design.

VI. Software Development Process Framework

Workflow Stages of the Process

1. Communication: Stakeholder requirements gathering.

2. Planning: Estimate, schedule, resource allocation.

3. Modeling: Analysis/design (UML, data flow).

4. Construction: Coding, unit testing.

5. Deployment: Delivery to user environment.

6. Operation & Maintenance: Post-deployment support.

Process Checkpoints (Milestones, Reviews)

• Milestones: Dates by which specific deliverables must be completed (e.g., “requirements signed off”).

• Reviews: Formal assessments at milestones (e.g., Technical Review, Inspection, Walkthrough).

• Purpose: Ensure quality, alignment, and go/no-go decisions.

Task Set: Definition & Selection Steps

• Definition: Collection of tasks (work products) required for a project.

• Selection Steps:

  1. Identify Project Type (e.g., new development, enhancement).

  2. Assess Project Characteristics (size, criticality, team experience).

  3. Choose Process Model (waterfall, agile, hybrid).

  4. Tailor Task Set (include/exclude tasks based on risk, compliance).

  5. Validate with Stakeholders.

Iterative Process Planning Approach (with Example)

• Plan in iterations/sprints (e.g., 2–4 weeks).

• Each iteration delivers a working increment.

• Example (Agile Scrum):

  • Sprint 1: Plan backlog items → develop login/auth → demo to product owner.

  • Sprint 2: Plan next set → develop user profile → integrate with login.

• Benefits: Early feedback, risk reduction, adaptability.

Process Discriminants (Factors Differentiating Processes)

• Project Size & Complexity

• Team Experience & Distribution

• Regulatory/Compliance Requirements (e.g., medical, aviation)

• Customer Involvement Level

• Technology Novelty & Stability

• Time-to-Market Pressure

VII. Project Organization & Team Management

Structure and Roles Within a Project Organization

Responsibilities and Organization of a Project Team

• Clear Role Definitions: RACI matrix (Responsible, Accountable, Consulted, Informed).

• Team Composition: Balanced skill sets (frontend, backend, DB, testing).

• Reporting Lines: Functional (to department) vs. projectized (to PM).

• Co-location vs. Distributed: Communication tools, meeting cadence.

Software Management Team: Composition and Function

• Composition: PM, tech lead, product owner, QA lead, DevOps lead.

• Functions:

  • Strategic Alignment: Ensure project meets business objectives.

  • Resource Allocation: Assign staff, manage budgets.

  • Issue Resolution: Escalate and resolve blockers.

  • Quality Governance: Define standards, review artifacts.

  • Stakeholder Communication: Regular status updates.

Organizing Various Stakeholders for Effective Software Engineering

• Identify Stakeholders: Customers, users, sponsors, regulators, support teams.

• Engagement Plan: Frequency, channels (meetings, reports), decision rights.

• Collaboration Mechanisms: Joint workshops, shared tools (Jira, Confluence).

• Conflict Resolution: Clear escalation paths.

Role of Multidisciplinary Teams in Project Planning

• Bring diverse expertise (business, tech, UX, ops) early.

• Benefits:

  • Holistic estimates (effort, cost).

  • Early identification of dependencies/risks.

  • Shared ownership → better commitment.

• Example: In planning a healthcare app, include doctors, nurses, security experts, developers.

VIII. Process Automation

Definition & Purpose

• Definition: Use of tools to execute repetitive, rule-based tasks in software development with minimal human intervention.

• Purpose: Increase speed, reduce errors, free humans for creative work, ensure consistency.

Process Automation Structure & How It Works

1. Trigger: Event (code commit, schedule).

2. Task Execution: Scripts/tools run (build, test, scan).

3. Decision: Pass/fail → next step or alert.

4. Feedback: Notify team, log results.

• Tools: Jenkins, GitHub Actions, Ansible, Selenium.

Four Stages of Process Automation

1. Task Automation: Single tasks (e.g., code formatting).

2. Workflow Automation: Sequence of tasks (e.g., build → test → package).

3. Process Automation: End-to-end pipelines (CI/CD).

4. Intelligent Automation: AI/ML for decision-making (e.g., test case generation).

Need & Benefits

• Need: Manual processes are slow, error-prone, not scalable.

• Benefits:

  • Faster time-to-market.

  • Higher quality (consistent runs).

  • Reduced labor costs.

  • Audit trail & compliance.

Examples in Software Development

• CI/CD Pipelines: Automated build, test, deployment.

• Infrastructure as Code (IaC): Terraform, CloudFormation.

• Automated Testing: Unit, integration, UI tests.

• Code Analysis: Static (SonarQube), security scanning (OWASP ZAP).

IX. Process Measurement & Control

Key Management Indicators (KMIs) / Process Measurement Tools

• Productivity: Lines of code/person-month, story points/iteration.

• Quality: Defect density, escape rate, test coverage.

• Schedule: On-time delivery %, schedule variance (SV).

• Cost: Cost variance (CV), budget burn rate.

• Flow: Lead time, cycle time, throughput.

• Tools: Jira, Azure DevOps, custom dashboards.

Project Control & Process Instrumentation

• Project Control: Monitoring progress vs. plan, taking corrective action.

• Process Instrumentation: Embedding metrics collection into tools (e.g., CI server logs build times).

Four Steps in Project Control Process

1. Establish Baselines: Define scope, schedule, cost baselines.

2. Measure Performance: Collect actual data (effort, defects).

3. Compare & Analyze: Variance analysis (e.g., EVM: CPI, SPI).

4. Take Corrective Action: Replan, reallocate, scope adjustment.

Success Factors in Project Control Systems

• Timely, Accurate Data: Automated collection.

• Clear Baselines: Agreed upon with stakeholders.

• Regular Reviews: Frequent check-ins (daily standups, weekly reviews).

• Empowered PM: Authority to enact changes.

• Stakeholder Buy-in: Transparency in reporting.

Problems in Project Control

• Poor Estimation: Unrealistic baselines.

• Data Latency: Delayed metrics → slow response.

• Scope Creep: Uncontrolled changes.

• Resistance to Change: Team ignores metrics.

• Tool Overload: Too many metrics → confusion.

X. Risk Management

Risk Identification Techniques

• Brainstorming: Team workshops.

• Checklist Analysis: Historical risk lists.

• SWOT Analysis: Strengths, Weaknesses, Opportunities, Threats.

• Delphi Technique: Anonymous expert consensus.

• Assumption Analysis: Challenge project assumptions.

• Diagramming: Cause-effect, process flow.

Monitoring and Managing Risks

• Risk Register: Log with probability, impact, owner, mitigation plan.

• Regular Reviews: Update status in meetings.

• Triggers: Define early warning signs.

• Mitigation Strategies: Avoid, transfer, mitigate, accept.

Warning Signs Indicating Project at Risk

• Schedule: Missed milestones, slipping deadlines.

• Budget: Cost overruns, unexplained expenses.

• Quality: Rising defect rates, failed tests.

• Team: Low morale, high turnover, absenteeism.

• Stakeholders: Escalating complaints, lack of engagement.

• Requirements: Frequent changes, ambiguity.

Actions to Address Project Risks

• Replan: Adjust scope, schedule, resources.

• Escalate: Inform sponsors for support.

• Mitigate: Implement risk response plan (e.g., add resources, simplify scope).

• Communicate: Transparent updates to stakeholders.

• Retrospect: Learn and update risk management process.

XI. Supporting Engineering Processes

Software Configuration Management (SCM): Process & Necessity

• Process:

  1. Identification: Unique IDs for config items (code, docs).

  2. Version Control: Track changes (Git, SVN).

  3. Change Control: Review/approve modifications via CAB.

  4. Status Accounting: Audit trail of changes.

  5. Audits & Reviews: Verify integrity.

• Necessity:

  • Prevent accidental overwrites.

  • Reproduce past versions (bug fixes).

  • Coordinate team changes.

  • Compliance (e.g., ISO, CMMI).

Software Maintenance: Definition & Types

• Definition: Modifications after delivery to correct, improve, or adapt software.

• Types:

  | Type | Purpose | Example | |------|---------|---------| | Corrective | Fix defects | Patch security vulnerability. | | Adaptive | Adapt to environment | Update for new OS version. | | Perfective | Enhance performance/usability | Optimize query speed, add UI feature. | | Preventive | Prevent future issues | Refactor code to reduce technical debt. |

XII. Additional Contextual Concepts

Project Environment (Factors Influencing Projects)

• Organizational Culture: Agile vs. hierarchical.

• Market Conditions: Competition, customer expectations.

• Technology Landscape: Available tools, frameworks, infrastructure.

• Regulatory/Compliance: Legal constraints (GDPR, HIPAA).

• Team Dynamics: Skills, location, communication.

Strategic, Technical, and Economic Impact Assessment Methods

• Strategic: SWOT, balanced scorecard, alignment with business goals.

• Technical: Feasibility studies, proof-of-concept, architecture evaluation (ATAM).

• Economic: Cost-benefit analysis, NPV, ROI, TCO, real options analysis.

Future Trends in Process Improvement

• AI-Assisted Development: GitHub Copilot, automated testing.

• Value Stream Management: End-to-end flow optimization.

• DevSecOps: Security integrated early.

• Platform Engineering: Self-service developer platforms.

• Remote Collaboration Tools: VR/AR for distributed teams.

[!TIP]

Exam Focus: Risk warning signs, SCM process, maintenance types, and assessment methods are high-frequency. Use real-world examples (e.g., GDPR for regulatory impact).